| /* |
| * Copyright 2010 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // Author: sligocki@google.com (Shawn Ligocki) |
| |
| #include "net/instaweb/rewriter/public/css_filter.h" |
| |
| #include <algorithm> // for std::merge. |
| #include <map> |
| #include <utility> // for pair |
| #include <vector> |
| |
| #include "base/logging.h" |
| #include "net/instaweb/http/public/async_fetch.h" |
| #include "net/instaweb/http/public/log_record.h" |
| #include "net/instaweb/rewriter/cached_result.pb.h" |
| #include "net/instaweb/rewriter/public/association_transformer.h" |
| #include "net/instaweb/rewriter/public/css_absolutify.h" |
| #include "net/instaweb/rewriter/public/css_flatten_imports_context.h" |
| #include "net/instaweb/rewriter/public/css_hierarchy.h" |
| #include "net/instaweb/rewriter/public/css_image_rewriter.h" |
| #include "net/instaweb/rewriter/public/css_minify.h" |
| #include "net/instaweb/rewriter/public/css_tag_scanner.h" |
| #include "net/instaweb/rewriter/public/css_url_counter.h" |
| #include "net/instaweb/rewriter/public/css_util.h" |
| #include "net/instaweb/rewriter/public/data_url_input_resource.h" |
| #include "net/instaweb/rewriter/public/image_rewrite_filter.h" |
| #include "net/instaweb/rewriter/public/image_url_encoder.h" |
| #include "net/instaweb/rewriter/public/inline_attribute_slot.h" |
| #include "net/instaweb/rewriter/public/inline_output_resource.h" |
| #include "net/instaweb/rewriter/public/inline_resource_slot.h" |
| #include "net/instaweb/rewriter/public/output_resource.h" |
| #include "net/instaweb/rewriter/public/request_properties.h" |
| #include "net/instaweb/rewriter/public/resource.h" |
| #include "net/instaweb/rewriter/public/resource_slot.h" |
| #include "net/instaweb/rewriter/public/resource_tag_scanner.h" |
| #include "net/instaweb/rewriter/public/rewrite_context.h" |
| #include "net/instaweb/rewriter/public/rewrite_driver.h" |
| #include "net/instaweb/rewriter/public/rewrite_options.h" |
| #include "net/instaweb/rewriter/public/rewrite_result.h" |
| #include "net/instaweb/rewriter/public/server_context.h" |
| #include "net/instaweb/rewriter/public/single_rewrite_context.h" |
| #include "net/instaweb/rewriter/public/usage_data_reporter.h" |
| #include "pagespeed/kernel/base/basictypes.h" |
| #include "pagespeed/kernel/base/charset_util.h" |
| #include "pagespeed/kernel/base/hasher.h" |
| #include "pagespeed/kernel/base/message_handler.h" |
| #include "pagespeed/kernel/base/scoped_ptr.h" |
| #include "pagespeed/kernel/base/statistics.h" |
| #include "pagespeed/kernel/base/string.h" |
| #include "pagespeed/kernel/base/string_util.h" |
| #include "pagespeed/kernel/base/string_writer.h" |
| #include "pagespeed/kernel/html/html_element.h" |
| #include "pagespeed/kernel/html/html_name.h" |
| #include "pagespeed/kernel/html/html_node.h" |
| #include "pagespeed/kernel/http/content_type.h" |
| #include "pagespeed/kernel/http/data_url.h" |
| #include "pagespeed/kernel/http/google_url.h" |
| #include "pagespeed/kernel/http/response_headers.h" |
| #include "pagespeed/kernel/util/simple_random.h" |
| #include "pagespeed/opt/logging/enums.pb.h" |
| #include "webutil/css/parser.h" |
| |
| #include "base/at_exit.h" |
| |
| namespace { |
| |
| base::AtExitManager* at_exit_manager = NULL; |
| |
| } // namespace |
| |
| namespace net_instaweb { |
| |
| class CacheExtender; |
| class ImageCombineFilter; |
| |
| namespace { |
| |
| // A simple transformer that resolves URLs against a base. Unlike |
| // RewriteDomainTransformer, does not do any mapping or trimming. |
| class SimpleAbsolutifyTransformer : public CssTagScanner::Transformer { |
| public: |
| explicit SimpleAbsolutifyTransformer(const GoogleUrl* base_url) |
| : base_url_(base_url) {} |
| virtual ~SimpleAbsolutifyTransformer() {} |
| |
| virtual TransformStatus Transform(GoogleString* str) { |
| GoogleUrl abs(*base_url_, *str); |
| if (abs.IsWebValid()) { |
| abs.Spec().CopyToString(str); |
| return kSuccess; |
| } else { |
| return kNoChange; |
| } |
| } |
| |
| private: |
| const GoogleUrl* base_url_; |
| DISALLOW_COPY_AND_ASSIGN(SimpleAbsolutifyTransformer); |
| }; |
| |
| // All of the options that can affect image optimization can also affect |
| // CSS rewriting, due to embedded images. We will merge those in during |
| // Initialize. There are additional options that affect CSS files. Notably, |
| // image inlining does not affect the http* URLs of images, but it does affect |
| // the URLs of CSS files because images inlined into CSS changes the hash. |
| const RewriteOptions::Filter kRelatedFilters[] = { |
| RewriteOptions::kExtendCacheCss, |
| RewriteOptions::kExtendCacheImages, |
| RewriteOptions::kFallbackRewriteCssUrls, |
| RewriteOptions::kFlattenCssImports, |
| RewriteOptions::kInlineImages, |
| RewriteOptions::kLeftTrimUrls, |
| RewriteOptions::kRewriteDomains, |
| RewriteOptions::kSpriteImages, |
| }; |
| const int kRelatedFiltersSize = arraysize(kRelatedFilters); |
| |
| const char* const kRelatedOptions[] = { |
| RewriteOptions::kCssFlattenMaxBytes, |
| RewriteOptions::kCssImageInlineMaxBytes, |
| RewriteOptions::kCssPreserveURLs, |
| RewriteOptions::kImagePreserveURLs, |
| RewriteOptions::kMaxUrlSegmentSize, |
| RewriteOptions::kMaxUrlSize, |
| }; |
| |
| bool IsInlineResource(const ResourcePtr& resource) { |
| // InlineOutputResources have no URL, but original inline resources are |
| // stored as DataUrlInputResources, thus have data url() |
| // TODO(sligocki): Harmonize these all to use the same method. |
| return (!resource->has_url() || IsDataUrl(resource->url())); |
| } |
| |
| } // namespace |
| |
| const RewriteOptions::Filter* CssFilter::merged_filters_ = NULL; |
| int CssFilter::merged_filters_size_ = 0; |
| |
| StringPieceVector* CssFilter::related_options_ = NULL; |
| |
| // Statistics variable names. |
| const char CssFilter::kBlocksRewritten[] = "css_filter_blocks_rewritten"; |
| const char CssFilter::kParseFailures[] = "css_filter_parse_failures"; |
| const char CssFilter::kFallbackRewrites[] = "css_filter_fallback_rewrites"; |
| const char CssFilter::kFallbackFailures[] = "css_filter_fallback_failures"; |
| const char CssFilter::kRewritesDropped[] = "css_filter_rewrites_dropped"; |
| const char CssFilter::kTotalBytesSaved[] = "css_filter_total_bytes_saved"; |
| const char CssFilter::kTotalOriginalBytes[] = "css_filter_total_original_bytes"; |
| const char CssFilter::kUses[] = "css_filter_uses"; |
| const char CssFilter::kCharsetMismatch[] = "flatten_imports_charset_mismatch"; |
| const char CssFilter::kInvalidUrl[] = "flatten_imports_invalid_url"; |
| const char CssFilter::kLimitExceeded[] = "flatten_imports_limit_exceeded"; |
| const char CssFilter::kMinifyFailed[] = "flatten_imports_minify_failed"; |
| const char CssFilter::kRecursion[] = "flatten_imports_recursion"; |
| const char CssFilter::kComplexQueries[] = "flatten_imports_complex_queries"; |
| |
| CssFilter::Context::Context(CssFilter* filter, RewriteDriver* driver, |
| RewriteContext* parent, |
| CacheExtender* cache_extender, |
| ImageRewriteFilter* image_rewriter, |
| ImageCombineFilter* image_combiner, |
| ResourceContext* context) |
| : SingleRewriteContext(driver, parent, context), |
| filter_(filter), |
| css_image_rewriter_( |
| new CssImageRewriter(this, filter, |
| cache_extender, image_rewriter, |
| image_combiner)), |
| image_rewrite_filter_(image_rewriter), |
| hierarchy_(filter), |
| css_rewritten_(false), |
| has_utf8_bom_(false), |
| fallback_mode_(false), |
| rewrite_element_(NULL), |
| rewrite_inline_element_(NULL), |
| rewrite_inline_char_node_(NULL), |
| rewrite_inline_attribute_(NULL), |
| rewrite_inline_css_kind_(kInsideStyleTag), |
| in_text_size_(-1) { |
| initial_css_base_gurl_.Reset(filter_->decoded_base_url()); |
| DCHECK(initial_css_base_gurl_.IsWebValid()); |
| initial_css_trim_gurl_.Reset(initial_css_base_gurl_); |
| } |
| |
| CssFilter::Context::~Context() { |
| } |
| |
| // The base URL used when absolutifying sub-resources must be the input |
| // URL of this rewrite. |
| // |
| // The only exception is the case of inline CSS, where we define the |
| // input URL to be a data: URL. In this case the base URL is the URL of |
| // the HTML page, which we save to initial_... in the constructor. |
| // |
| // When our input is the output of CssCombiner, the initial_css_base_gurl_ here |
| // is stale (it's the first input to the combination). It ought to be |
| // the URL of the output of the combination. Similarly css_trim_gurl |
| // needs to be set from the ultimate output resource and not just |
| // initial_css_trim_gurl_. This matters because for a cross-directory |
| // combine we can end up moving a few directories up, and further a UrlNamer |
| // might even end up moving some things to a separate cookieless domain. |
| // |
| // Note that we have to do it functionally and not in RewriteSingle since these |
| // may be invoked from Absolutify, which may be invoked from a |
| // different thread when doing fallback due to a deadline. This also means that |
| // initial_css_base_gurl_ and initial_css_trim_gurl_ must indeed just be |
| // initials and not be mutated. |
| void CssFilter::Context::GetCssBaseUrlToUse( |
| const ResourcePtr& input_resource, GoogleUrl* css_base_gurl_to_use) { |
| if (!IsInlineResource(input_resource)) { |
| css_base_gurl_to_use->Reset(input_resource->url()); |
| } else { |
| css_base_gurl_to_use->Reset(initial_css_base_gurl_); |
| } |
| } |
| |
| void CssFilter::Context::GetCssTrimUrlToUse( |
| const ResourcePtr& input_resource, |
| const StringPiece& output_url_base, |
| GoogleUrl* css_trim_gurl_to_use) { |
| if (!IsInlineResource(input_resource)) { |
| css_trim_gurl_to_use->Reset(output_url_base); |
| } else { |
| css_trim_gurl_to_use->Reset(initial_css_trim_gurl_); |
| } |
| } |
| |
| void CssFilter::Context::GetCssTrimUrlToUse( |
| const ResourcePtr& input_resource, |
| const OutputResourcePtr& output_resource, |
| GoogleUrl* css_trim_gurl_to_use) { |
| if (!IsInlineResource(input_resource)) { |
| css_trim_gurl_to_use->Reset(output_resource->UrlEvenIfHashNotSet()); |
| } else { |
| css_trim_gurl_to_use->Reset(initial_css_trim_gurl_); |
| } |
| } |
| |
| bool CssFilter::Context::SendFallbackResponse( |
| StringPiece output_url_base, |
| StringPiece input_contents, |
| AsyncFetch* async_fetch, |
| MessageHandler* handler) { |
| // Do not set the content length, since we may need to mutate the |
| // content as we stream out the bytes to correct for URL changes. |
| async_fetch->HeadersComplete(); |
| |
| DCHECK_EQ(1, num_slots()); |
| ResourcePtr input_resource(slot(0)->resource()); |
| DCHECK(input_resource.get() != NULL); |
| |
| GoogleUrl css_base_gurl_to_use; |
| GetCssBaseUrlToUse(input_resource, &css_base_gurl_to_use); |
| |
| GoogleUrl css_trim_gurl_to_use; |
| GetCssTrimUrlToUse(input_resource, output_url_base, &css_trim_gurl_to_use); |
| |
| bool ret = false; |
| switch (Driver()->ResolveCssUrls(css_base_gurl_to_use, |
| css_trim_gurl_to_use.Spec(), |
| input_contents, async_fetch, handler)) { |
| case RewriteDriver::kNoResolutionNeeded: |
| case RewriteDriver::kWriteFailed: |
| // If kNoResolutionNeeded, we just write out the input_contents, because |
| // nothing needed to be changed. |
| // |
| // If kWriteFailed, this means that the URLs couldn't be transformed |
| // (or that writer->Write() actually failed ... I think this shouldn't |
| // generally happen). So, we just push out the unedited original, |
| // figuring that must be better than nothing. |
| // |
| // TODO(sligocki): In the fetch path ResolveCssUrls should never fail |
| // to transform URLs. We should just absolutify all the ones we can. |
| ret = async_fetch->Write(input_contents, handler); |
| break; |
| case RewriteDriver::kSuccess: |
| ret = true; |
| break; |
| } |
| return ret; |
| } |
| |
| void CssFilter::Context::Render() { |
| if (num_output_partitions() == 0) { |
| return; |
| } |
| |
| DCHECK(has_parent() || (rewrite_element_ != NULL)); |
| |
| const CachedResult& result = *output_partition(0); |
| if (result.optimizable()) { |
| // Note: All actual rendering is done inside ResourceSlot::Render() methods. |
| if (rewrite_inline_char_node_ == NULL && |
| rewrite_inline_attribute_ == NULL) { |
| // External css. |
| Driver()->log_record()->SetRewriterLoggingStatus( |
| id(), slot(0)->resource()->url(), RewriterApplication::APPLIED_OK); |
| } |
| filter_->num_uses_->Add(1); |
| } |
| |
| if (Driver()->options()->Enabled( |
| RewriteOptions::kExperimentCollectMobImageInfo) && |
| !has_parent() /* only report at top-level*/) { |
| for (int i = 0; i < result.associated_image_info_size(); ++i) { |
| image_rewrite_filter_->RegisterImageInfo(result.associated_image_info(i)); |
| } |
| } |
| } |
| |
| void CssFilter::Context::SetupInlineRewrite(HtmlElement* style_element, |
| HtmlCharactersNode* text) { |
| // To handle nested rewrites of inline CSS, we internally handle it |
| // as a rewrite of a data: URL. |
| rewrite_element_ = style_element; |
| rewrite_inline_element_ = style_element; |
| rewrite_inline_char_node_ = text; |
| rewrite_inline_css_kind_ = kInsideStyleTag; |
| } |
| |
| void CssFilter::Context::SetupAttributeRewrite(HtmlElement* element, |
| HtmlElement::Attribute* src, |
| InlineCssKind inline_css_kind) { |
| DCHECK(inline_css_kind == kAttributeWithoutUrls || |
| inline_css_kind == kAttributeWithUrls); |
| rewrite_element_ = element; |
| rewrite_inline_element_ = element; |
| rewrite_inline_attribute_ = src; |
| rewrite_inline_css_kind_ = inline_css_kind; |
| } |
| |
| void CssFilter::Context::SetupExternalRewrite(HtmlElement* element, |
| const GoogleUrl& base_gurl, |
| const GoogleUrl& trim_gurl) { |
| rewrite_element_ = element; |
| initial_css_base_gurl_.Reset(base_gurl); |
| initial_css_trim_gurl_.Reset(trim_gurl); |
| } |
| |
| void CssFilter::Context::RewriteSingle( |
| const ResourcePtr& input_resource, |
| const OutputResourcePtr& output_resource) { |
| int drop_percentage = Options()->rewrite_random_drop_percentage(); |
| if (drop_percentage > 0) { |
| SimpleRandom* simple_random = FindServerContext()->simple_random(); |
| if (drop_percentage > static_cast<int>(simple_random->Next() % 100)) { |
| return RewriteDone(kTooBusy, 0); |
| } |
| } |
| |
| bool is_ipro = IsNestedIn(RewriteOptions::kInPlaceRewriteId); |
| AttachDependentRequestTrace(is_ipro ? "IproProcessCSS" : "ProcessCSS"); |
| input_resource_ = input_resource; |
| output_resource_ = output_resource; |
| StringPiece input_contents = input_resource_->ExtractUncompressedContents(); |
| in_text_size_ = input_contents.size(); |
| has_utf8_bom_ = StripUtf8Bom(&input_contents); |
| |
| GoogleUrl css_base_gurl_to_use; |
| GetCssBaseUrlToUse(input_resource, &css_base_gurl_to_use); |
| GoogleUrl css_trim_gurl_to_use; |
| GetCssTrimUrlToUse(input_resource, output_resource_, &css_trim_gurl_to_use); |
| bool parsed = RewriteCssText( |
| css_base_gurl_to_use, css_trim_gurl_to_use, input_contents, in_text_size_, |
| IsInlineAttribute() /* text_is_declarations */, |
| Driver()->message_handler()); |
| |
| if (parsed) { |
| if (num_nested() > 0) { |
| StartNestedTasks(); |
| } else { |
| // We call Harvest() ourselves so we can centralize all the output there. |
| Harvest(); |
| } |
| } else { |
| RewriteDone(kRewriteFailed, 0); |
| } |
| } |
| |
| // Return value answers the question: May we rewrite? |
| // css_base_gurl is the URL used to resolve relative URLs in the CSS. |
| // css_trim_gurl is the URL used to trim absolute URLs to relative URLs. |
| // Specifically, it should be the address of the CSS document itself for |
| // external CSS or the HTML document that the CSS is in for inline CSS. |
| bool CssFilter::Context::RewriteCssText(const GoogleUrl& css_base_gurl, |
| const GoogleUrl& css_trim_gurl, |
| const StringPiece& in_text, |
| int64 in_text_size, |
| bool text_is_declarations, |
| MessageHandler* handler) { |
| // Load stylesheet w/o expanding background attributes and preserving as |
| // much content as possible from the original document. |
| Css::Parser parser(in_text); |
| parser.set_preservation_mode(true); |
| // We avoid quirks-mode so that we do not "fix" something we shouldn't have. |
| parser.set_quirks_mode(false); |
| // Create a stylesheet even if given declarations so that we don't need |
| // two versions of everything, though they do need to handle a stylesheet |
| // with no selectors in it, which they currently do. |
| scoped_ptr<Css::Stylesheet> stylesheet; |
| if (text_is_declarations) { |
| Css::Declarations* declarations = parser.ParseRawDeclarations(); |
| if (declarations != NULL) { |
| stylesheet.reset(new Css::Stylesheet()); |
| Css::Ruleset* ruleset = new Css::Ruleset(); |
| stylesheet->mutable_rulesets().push_back(ruleset); |
| ruleset->set_declarations(declarations); |
| } |
| } else { |
| stylesheet.reset(parser.ParseRawStylesheet()); |
| } |
| |
| bool parsed = true; |
| if (stylesheet.get() == NULL || |
| parser.errors_seen_mask() != Css::Parser::kNoError) { |
| parsed = false; |
| Driver()->message_handler()->Message( |
| kWarning, "CSS parsing error in %s", css_base_gurl.spec_c_str()); |
| filter_->num_parse_failures_->Add(1); |
| |
| // Report all parse errors (Note: Some of these are errors we recovered |
| // from by passing through unparsed sections of text). |
| for (int i = 0, n = parser.errors_seen().size(); i < n; ++i) { |
| Css::Parser::ErrorInfo error = parser.errors_seen()[i]; |
| Driver()->server_context()->usage_data_reporter()->ReportWarning( |
| css_base_gurl, error.error_num, error.message); |
| } |
| |
| // TODO(sligocki): Do we want to add the actual parse errors to this |
| // comment? There are often a lot and they can be quite long, so I'm not |
| // sure it's the best idea. Perhaps better to ask users to use the command |
| // line utility? Or is it better to give them all the info in one place? |
| output_partition(0)->add_debug_message(StrCat( |
| "CSS rewrite failed: Parse error in ", css_base_gurl.Spec())); |
| } else { |
| // Edit stylesheet. |
| // Any problem with an @import results in the error mask bit kImportError |
| // being set, so if we get here we know that any @import rules were parsed |
| // successfully, thus, flattening is safe. |
| bool has_unparseables = (parser.unparseable_sections_seen_mask() != |
| Css::Parser::kNoError); |
| RewriteCssFromRoot(css_base_gurl, css_trim_gurl, in_text, in_text_size, |
| has_unparseables, stylesheet.release()); |
| } |
| |
| if (!parsed && |
| Driver()->options()->Enabled(RewriteOptions::kFallbackRewriteCssUrls)) { |
| parsed = FallbackRewriteUrls(css_base_gurl, css_trim_gurl, in_text); |
| } |
| |
| return parsed; |
| } |
| |
| void CssFilter::Context::RewriteCssFromRoot(const GoogleUrl& css_base_gurl, |
| const GoogleUrl& css_trim_gurl, |
| const StringPiece& contents, |
| int64 in_text_size, |
| bool has_unparseables, |
| Css::Stylesheet* stylesheet) { |
| DCHECK_EQ(in_text_size_, in_text_size); |
| |
| hierarchy_.InitializeRoot(css_base_gurl, css_trim_gurl, |
| contents, has_unparseables, |
| Driver()->options()->css_flatten_max_bytes(), |
| stylesheet, Driver()->message_handler()); |
| |
| css_rewritten_ = css_image_rewriter_->RewriteCss(ImageInlineMaxBytes(), |
| this, |
| &hierarchy_, |
| Driver()->message_handler()); |
| } |
| |
| void CssFilter::Context::RewriteCssFromNested(RewriteContext* parent, |
| CssHierarchy* hierarchy) { |
| css_image_rewriter_->RewriteCss(ImageInlineMaxBytes(), parent, hierarchy, |
| Driver()->message_handler()); |
| } |
| |
| // Fallback to rewriting URLs using CssTagScanner because of failure to parse. |
| // Note: We do not flatten CSS during fallback processing. |
| // TODO(sligocki): Allow recursive rewriting of @imported CSS files. |
| bool CssFilter::Context::FallbackRewriteUrls( |
| const GoogleUrl& css_base_gurl, const GoogleUrl& css_trim_gurl, |
| const StringPiece& in_text) { |
| fallback_mode_ = true; |
| |
| // We need permanent copies of these since fallback transformers |
| // keep pointers. |
| base_gurl_for_fallback_.reset(new GoogleUrl()); |
| base_gurl_for_fallback_->Reset(css_base_gurl); |
| trim_gurl_for_fallback_.reset(new GoogleUrl()); |
| trim_gurl_for_fallback_->Reset(css_trim_gurl); |
| |
| bool ret = false; |
| // In order to rewrite CSS using only the CssTagScanner, we run two scans. |
| // Here we just record all URLs found with the CssUrlCounter. |
| // The second run will be in Harvest() after all the subresources have been |
| // rewritten. |
| CssUrlCounter url_counter(&css_base_gurl, Driver()->message_handler()); |
| if (url_counter.Count(in_text)) { |
| // TransformUrls will succeed only if all the URLs in the CSS file |
| // were parseable. If we encounter any unparseable URLs, we will not |
| // be able to absolutify them and so should not rewrite the CSS. |
| ret = true; |
| |
| // Setup absolutifier used by fallback_transformer_. Only enable it if |
| // we need to absolutify resources. Otherwise leave it as NULL. |
| bool proxy_mode; |
| RewriteDriver* driver = Driver(); |
| if (driver->ShouldAbsolutifyUrl(css_base_gurl, css_trim_gurl, |
| &proxy_mode)) { |
| absolutifier_.reset(new RewriteDomainTransformer( |
| base_gurl_for_fallback_.get(), trim_gurl_for_fallback_.get(), |
| driver->server_context(), driver->options(), |
| driver->message_handler())); |
| if (proxy_mode) { |
| absolutifier_->set_trim_urls(false); |
| } |
| } |
| // fallback_transformer_ will be used in the second pass (in Harvest()) |
| // to rewrite the URLs. |
| // We instantiate it here so that all the slots below can be set to render |
| // into it. When they are rendered they will set the map used by |
| // AssociationTransformer. |
| fallback_transformer_.reset(new AssociationTransformer( |
| base_gurl_for_fallback_.get(), driver->options(), absolutifier_.get(), |
| driver->message_handler())); |
| |
| const StringIntMap& url_counts = url_counter.url_counts(); |
| for (StringIntMap::const_iterator it = url_counts.begin(); |
| it != url_counts.end(); ++it) { |
| const GoogleUrl url(it->first); |
| // TODO(sligocki): Use count of occurrences to decide which URLs to |
| // inline. it->second has the count of how many occurrences of this |
| // URL there were. |
| // This is guaranteed by CssUrlCounter. |
| CHECK(url.IsAnyValid()) << it->first; |
| // Add slot. |
| bool is_authorized; |
| ResourcePtr resource = Driver()->CreateInputResource(url, &is_authorized); |
| if (resource.get()) { |
| ResourceSlotPtr slot(new AssociationSlot( |
| resource, fallback_transformer_->map(), url.Spec())); |
| css_image_rewriter_->RewriteSlot(slot, ImageInlineMaxBytes(), this); |
| } else if (!is_authorized) { |
| output_partition(0)->add_debug_message( |
| StrCat("A resource was not rewritten because ", url.Host(), |
| " is not an authorized domain")); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| void CssFilter::Context::Harvest() { |
| GoogleString out_text; |
| bool ok = false; |
| |
| // Propagate any info on images from child rewrites. |
| CssImageRewriter::InheritChildImageInfo(this); |
| |
| if (fallback_mode_) { |
| // If CSS was not successfully parsed. |
| if (fallback_transformer_.get() != NULL) { |
| StringWriter out(&out_text); |
| ok = CssTagScanner::TransformUrls( |
| input_resource_->ExtractUncompressedContents(), &out, |
| fallback_transformer_.get(), Driver()->message_handler()); |
| } |
| if (ok) { |
| filter_->num_fallback_rewrites_->Add(1); |
| } else { |
| filter_->num_fallback_failures_->Add(1); |
| GoogleUrl css_base_gurl; |
| GetCssBaseUrlToUse(input_resource_, &css_base_gurl); |
| output_partition(0)->add_debug_message(StrCat( |
| "CSS rewrite failed: Fallback transformer error in ", |
| css_base_gurl.Spec())); |
| } |
| |
| } else { |
| // If we are limiting the size of the flattened result, work that out now; |
| // simply rolling up the contents does that nicely. |
| if (hierarchy_.flattening_succeeded() && |
| hierarchy_.flattened_result_limit() > 0) { |
| hierarchy_.RollUpContents(); |
| } |
| |
| // If CSS was successfully parsed. |
| hierarchy_.RollUpStylesheets(); |
| |
| bool previously_optimized = false; |
| for (int i = 0; !previously_optimized && i < num_nested(); ++i) { |
| RewriteContext* nested_context = nested(i); |
| for (int j = 0; j < nested_context->num_slots(); ++j) { |
| if (nested_context->slot(j)->was_optimized()) { |
| previously_optimized = true; |
| break; |
| } |
| } |
| } |
| |
| GoogleUrl css_base_gurl_to_use; |
| GetCssBaseUrlToUse(input_resource_, &css_base_gurl_to_use); |
| |
| GoogleUrl css_trim_gurl_to_use; |
| GetCssTrimUrlToUse(input_resource_, output_resource_, |
| &css_trim_gurl_to_use); |
| |
| // May need to absolutify @import and/or url() URLs. Note we must invoke |
| // ShouldAbsolutifyUrl first because we need 'proxying' to be calculated. |
| bool absolutified_urls = false; |
| bool proxying = false; |
| bool should_absolutify = Driver()->ShouldAbsolutifyUrl(css_base_gurl_to_use, |
| css_trim_gurl_to_use, |
| &proxying); |
| if (should_absolutify) { |
| absolutified_urls = |
| CssAbsolutify::AbsolutifyImports(hierarchy_.mutable_stylesheet(), |
| css_base_gurl_to_use); |
| } |
| |
| // If we have determined that we need to absolutify URLs, or if we are |
| // proxying (*), we need to absolutify all URLs. If we have already run the |
| // CSS through the image rewriter then all parseable URLs have already been |
| // done, and we only need to do unparseable URLs if any were detected. |
| // (*) When proxying the root of the path can change so we need to |
| // absolutify. |
| if (should_absolutify || proxying) { |
| absolutified_urls |= CssAbsolutify::AbsolutifyUrls( |
| hierarchy_.mutable_stylesheet(), |
| css_base_gurl_to_use, |
| !css_rewritten_, /* handle_parseable_ruleset_sections */ |
| hierarchy_.unparseable_detected(), /* handle_unparseable_sections */ |
| Driver(), |
| Driver()->message_handler()); |
| } |
| |
| ok = SerializeCss( |
| in_text_size_, hierarchy_.mutable_stylesheet(), css_base_gurl_to_use, |
| css_trim_gurl_to_use, previously_optimized || absolutified_urls, |
| IsInlineAttribute() /* stylesheet_is_declarations */, has_utf8_bom_, |
| &out_text, Driver()->message_handler()); |
| } |
| |
| if (ok) { |
| if (rewrite_inline_element_ == NULL) { |
| ServerContext* server_context = FindServerContext(); |
| server_context->MergeNonCachingResponseHeaders(input_resource_, |
| output_resource_); |
| } else { |
| output_partition(0)->set_inlined_data(out_text); |
| output_partition(0)->set_is_inline_output_resource(true); |
| } |
| ok = Driver()->Write(ResourceVector(1, input_resource_), |
| out_text, |
| &kContentTypeCss, |
| input_resource_->charset(), |
| output_resource_.get()); |
| } |
| |
| if (!hierarchy_.flattening_failure_reason().empty()) { |
| output_partition(0)->add_debug_message( |
| hierarchy_.flattening_failure_reason()); |
| } |
| |
| if (ok) { |
| RewriteDone(kRewriteOk, 0); |
| } else { |
| RewriteDone(kRewriteFailed, 0); |
| } |
| } |
| |
| bool CssFilter::Context::SerializeCss(int64 in_text_size, |
| const Css::Stylesheet* stylesheet, |
| const GoogleUrl& css_base_gurl, |
| const GoogleUrl& css_trim_gurl, |
| bool previously_optimized, |
| bool stylesheet_is_declarations, |
| bool add_utf8_bom, |
| GoogleString* out_text, |
| MessageHandler* handler) { |
| bool ret = true; |
| |
| // Re-serialize stylesheet. |
| StringWriter writer(out_text); |
| if (add_utf8_bom) { |
| writer.Write(kUtf8Bom, handler); |
| } |
| if (stylesheet_is_declarations) { |
| CHECK_EQ(Css::Ruleset::RULESET, stylesheet->ruleset(0).type()); |
| CssMinify::Declarations(stylesheet->ruleset(0).declarations(), |
| &writer, handler); |
| } else { |
| CssMinify::Stylesheet(*stylesheet, &writer, handler); |
| } |
| |
| // Get signed versions so that we can subtract them. |
| int64 out_text_size = static_cast<int64>(out_text->size()); |
| int64 bytes_saved = in_text_size - out_text_size; |
| |
| if (!Driver()->options()->always_rewrite_css()) { |
| // Don't rewrite if we didn't edit it or make it any smaller. |
| if (!previously_optimized && bytes_saved <= 0) { |
| ret = false; |
| Driver()->InfoAt(this, "CSS parser increased size of CSS file %s by %s " |
| "bytes.", css_base_gurl.spec_c_str(), |
| Integer64ToString(-bytes_saved).c_str()); |
| filter_->num_rewrites_dropped_->Add(1); |
| output_partition(0)->add_debug_message(StrCat( |
| "CSS rewrite failed: Cannot improve ", css_base_gurl.Spec())); |
| } |
| } |
| |
| // Statistics |
| if (ret) { |
| filter_->num_blocks_rewritten_->Add(1); |
| filter_->total_bytes_saved_->Add(bytes_saved); |
| // TODO(sligocki): Will this be misleading if we flatten @imports? |
| filter_->total_original_bytes_->Add(in_text_size); |
| } |
| return ret; |
| } |
| |
| int64 CssFilter::Context::ImageInlineMaxBytes() const { |
| if (rewrite_inline_element_ != NULL) { |
| // We're in an html context. |
| return std::min( |
| Driver()->options()->ImageInlineMaxBytes(), |
| Driver()->options()->CssImageInlineMaxBytes()); |
| } else { |
| // We're in a standalone CSS file. |
| return Driver()->options()->CssImageInlineMaxBytes(); |
| } |
| } |
| |
| bool CssFilter::Context::Partition(OutputPartitions* partitions, |
| OutputResourceVector* outputs) { |
| if (rewrite_inline_element_ == NULL) { |
| return SingleRewriteContext::Partition(partitions, outputs); |
| } else { |
| // We use kOmitInputHash here as this is for inline content. |
| CachedResult* partition = partitions->add_partition(); |
| slot(0)->resource()->AddInputInfoToPartition( |
| Resource::kOmitInputHash, 0, partition); |
| OutputResourcePtr output_resource( |
| InlineOutputResource::MakeInlineOutputResource(Driver())); |
| output_resource->set_cached_result(partition); |
| outputs->push_back(output_resource); |
| return true; |
| } |
| } |
| |
| GoogleString CssFilter::Context::UserAgentCacheKey( |
| const ResourceContext* resource_context) const { |
| GoogleString key; |
| if (resource_context != NULL) { |
| // CSS cache-key is sensitive to whether the UA supports webp or not. |
| key = ImageUrlEncoder::CacheKeyFromResourceContext(*resource_context); |
| } |
| // The cache key we get from the image codec is not sufficient, as |
| // it does not produce different results if CSS image inlining is |
| // on, but of course the css rewriter does. |
| if ((Options()->CssImageInlineMaxBytes() != 0) && |
| Driver()->request_properties()->SupportsImageInlining()) { |
| StrAppend(&key, "I"); |
| } else { |
| StrAppend(&key, "A"); |
| } |
| return key; |
| } |
| |
| GoogleString CssFilter::Context::CacheKeySuffix() const { |
| GoogleString suffix; |
| if (rewrite_inline_element_ != NULL) { |
| // Incorporate the base path of the HTML as part of the key --- it |
| // matters for inline CSS since resources are resolved against |
| // that (while it doesn't for external CSS, since that uses the |
| // stylesheet as the base). |
| switch (rewrite_inline_css_kind_) { |
| case kInsideStyleTag: { |
| const Hasher* hasher = FindServerContext()->lock_hasher(); |
| StrAppend(&suffix, "_@", |
| hasher->Hash(initial_css_base_gurl_.AllExceptLeaf())); |
| break; |
| } |
| |
| case kAttributeWithUrls: { |
| // For attributes, we take a somewhat different strategy. There are |
| // a lot of them, and they can be repeated in many directories, |
| // so just appending the directory causes the metadata cache usage |
| // to balloon. Fortunately, they are also usually very short, |
| // so instead, we use the absolutified version of the data: URLs |
| // as a disambiguator, so that paths that resolve URLs the same way |
| // get the same keys. |
| GoogleString absolutified_version; |
| SimpleAbsolutifyTransformer transformer(&Driver()->decoded_base_url()); |
| StringWriter writer(&absolutified_version); |
| CssTagScanner::TransformUrls( |
| slot(0)->resource()->ExtractUncompressedContents(), &writer, |
| &transformer, Driver()->message_handler()); |
| |
| const Hasher* hasher = FindServerContext()->lock_hasher(); |
| StrAppend(&suffix, "_@", hasher->Hash(absolutified_version)); |
| break; |
| } |
| |
| case kAttributeWithoutUrls: { |
| // If there are no URLs, then there is no dependence on the |
| // path, either. |
| break; |
| } |
| } |
| } |
| |
| return suffix; |
| } |
| |
| CssFilter::CssFilter(RewriteDriver* driver, |
| CacheExtender* cache_extender, |
| ImageRewriteFilter* image_rewriter, |
| ImageCombineFilter* image_combiner) |
| : RewriteFilter(driver), |
| in_style_element_(false), |
| style_element_(NULL), |
| cache_extender_(cache_extender), |
| image_rewrite_filter_(image_rewriter), |
| image_combiner_(image_combiner) { |
| Statistics* stats = server_context()->statistics(); |
| num_blocks_rewritten_ = stats->GetVariable(CssFilter::kBlocksRewritten); |
| num_parse_failures_ = stats->GetVariable(CssFilter::kParseFailures); |
| num_fallback_rewrites_ = stats->GetVariable(CssFilter::kFallbackRewrites); |
| num_fallback_failures_ = stats->GetVariable(CssFilter::kFallbackFailures); |
| num_rewrites_dropped_ = stats->GetVariable(CssFilter::kRewritesDropped); |
| total_bytes_saved_ = stats->GetUpDownCounter(CssFilter::kTotalBytesSaved); |
| total_original_bytes_ = stats->GetVariable(CssFilter::kTotalOriginalBytes); |
| num_uses_ = stats->GetVariable(CssFilter::kUses); |
| num_flatten_imports_charset_mismatch_ = stats->GetVariable(kCharsetMismatch); |
| num_flatten_imports_invalid_url_ = stats->GetVariable(kInvalidUrl); |
| num_flatten_imports_limit_exceeded_ = stats->GetVariable(kLimitExceeded); |
| num_flatten_imports_minify_failed_ = stats->GetVariable(kMinifyFailed); |
| num_flatten_imports_recursion_ = stats->GetVariable(kRecursion); |
| num_flatten_imports_complex_queries_ = stats->GetVariable(kComplexQueries); |
| } |
| |
| CssFilter::~CssFilter() {} |
| |
| void CssFilter::InitStats(Statistics* statistics) { |
| statistics->AddVariable(CssFilter::kBlocksRewritten); |
| statistics->AddVariable(CssFilter::kParseFailures); |
| statistics->AddVariable(CssFilter::kFallbackRewrites); |
| statistics->AddVariable(CssFilter::kFallbackFailures); |
| statistics->AddVariable(CssFilter::kRewritesDropped); |
| statistics->AddUpDownCounter(CssFilter::kTotalBytesSaved); |
| statistics->AddVariable(CssFilter::kTotalOriginalBytes); |
| statistics->AddVariable(CssFilter::kUses); |
| statistics->AddVariable(CssFilter::kCharsetMismatch); |
| statistics->AddVariable(CssFilter::kInvalidUrl); |
| statistics->AddVariable(CssFilter::kLimitExceeded); |
| statistics->AddVariable(CssFilter::kMinifyFailed); |
| statistics->AddVariable(CssFilter::kRecursion); |
| statistics->AddVariable(CssFilter::kComplexQueries); |
| } |
| |
| namespace { |
| |
| // Merges arrays a & b and returns the result, allocated with new[]. Checks |
| // that the arrays were non-overlapping by verifying the size of the output |
| // array. |
| template<typename T> |
| T* MergeArrays(const T* a, int a_size, const T* b, int b_size, int* out_size) { |
| *out_size = a_size + b_size; |
| T* out = new T[*out_size]; |
| T* out_end = std::merge(a, a + a_size, b, b + b_size, out); |
| CHECK_EQ(*out_size, out_end - out); |
| return out; |
| } |
| |
| } // namespace |
| |
| void CssFilter::Initialize() { |
| InitializeAtExitManager(); |
| |
| CHECK(merged_filters_ == NULL); |
| #ifndef NDEBUG |
| for (int i = 1; i < kRelatedFiltersSize; ++i) { |
| CHECK_LT(kRelatedFilters[i - 1], kRelatedFilters[i]) |
| << "kRelatedFilters not in enum-value order"; |
| } |
| #endif |
| |
| merged_filters_ = MergeArrays(ImageRewriteFilter::kRelatedFilters, |
| ImageRewriteFilter::kRelatedFiltersSize, |
| kRelatedFilters, kRelatedFiltersSize, |
| &merged_filters_size_); |
| |
| CHECK(related_options_ == NULL); |
| related_options_ = new StringPieceVector; |
| ImageRewriteFilter::AddRelatedOptions(related_options_); |
| CssFilter::AddRelatedOptions(related_options_); |
| std::sort(related_options_->begin(), related_options_->end()); |
| } |
| |
| void CssFilter::Terminate() { |
| // Note: This is not thread-safe, but I don't believe we need it to be. |
| if (at_exit_manager != NULL) { |
| delete at_exit_manager; |
| at_exit_manager = NULL; |
| } |
| |
| CHECK(merged_filters_ != NULL); |
| delete [] merged_filters_; |
| merged_filters_ = NULL; |
| CHECK(related_options_ != NULL); |
| delete related_options_; |
| related_options_ = NULL; |
| } |
| |
| void CssFilter::AddRelatedOptions(StringPieceVector* target) { |
| for (int i = 0, n = arraysize(kRelatedOptions); i < n; ++i) { |
| target->push_back(kRelatedOptions[i]); |
| } |
| } |
| |
| void CssFilter::InitializeAtExitManager() { |
| // Note: This is not thread-safe, but I don't believe we need it to be. |
| if (at_exit_manager == NULL) { |
| at_exit_manager = new base::AtExitManager; |
| } |
| } |
| |
| void CssFilter::StartDocumentImpl() { |
| in_style_element_ = false; |
| meta_tag_charset_.clear(); |
| } |
| |
| void CssFilter::StartElementImpl(HtmlElement* element) { |
| // HtmlParse should not pass us elements inside a style element. |
| CHECK(!in_style_element_); |
| if (element->keyword() == HtmlName::kStyle) { |
| in_style_element_ = true; |
| style_element_ = element; |
| } else if (driver()->can_rewrite_resources()) { |
| bool do_rewrite = false; |
| bool check_for_url = false; |
| if (driver()->options()->Enabled(RewriteOptions::kRewriteStyleAttributes)) { |
| do_rewrite = true; |
| } else if (driver()->options()->Enabled( |
| RewriteOptions::kRewriteStyleAttributesWithUrl)) { |
| check_for_url = true; |
| } |
| |
| // Rewrite style attribute, if any, and iff enabled. |
| if (do_rewrite || check_for_url) { |
| // Per http://www.w3.org/TR/CSS21/syndata.html#uri s4.3.4 URLs and URIs: |
| // "The format of a URI value is 'url(' followed by ..." |
| HtmlElement::Attribute* element_style = element->FindAttribute( |
| HtmlName::kStyle); |
| if (element_style != NULL) { |
| bool has_url = |
| CssTagScanner::HasUrl(element_style->DecodedValueOrNull()); |
| if (!check_for_url || has_url) { |
| StartAttributeRewrite( |
| element, element_style, |
| has_url ? kAttributeWithUrls : kAttributeWithoutUrls); |
| } |
| } |
| } |
| } |
| // We deal with <link> elements in EndElement. |
| } |
| |
| void CssFilter::Characters(HtmlCharactersNode* characters_node) { |
| if (in_style_element_ && driver()->can_rewrite_resources()) { |
| // Note: HtmlParse should guarantee that we only get one CharactersNode |
| // per <style> block even if it is split by a flush. However, this code |
| // will still mostly work if we somehow got multiple CharacterNodes. |
| StartInlineRewrite(characters_node); |
| } |
| } |
| |
| void CssFilter::EndElementImpl(HtmlElement* element) { |
| // Rewrite an inline style. |
| if (in_style_element_) { |
| CHECK(style_element_ == element); // HtmlParse should not pass unmatching. |
| in_style_element_ = false; |
| } |
| if (driver()->IsRewritable(element)) { |
| resource_tag_scanner::UrlCategoryVector attributes; |
| resource_tag_scanner::ScanElement( |
| element, driver()->options(), &attributes); |
| resource_tag_scanner::UrlCategoryVector::iterator uc; |
| for (uc = attributes.begin(); uc != attributes.end(); uc++) { |
| if (uc->category == semantic_type::kStylesheet) { |
| StartExternalRewrite(element, uc->url); |
| } |
| } |
| } |
| if (meta_tag_charset_.empty() && element->keyword() == HtmlName::kMeta) { |
| // Note any meta tag charset specifier. |
| GoogleString content, mime_type, charset; |
| if (ExtractMetaTagDetails(*element, NULL, &content, &mime_type, &charset)) { |
| meta_tag_charset_ = charset; |
| } |
| } |
| } |
| |
| void CssFilter::StartInlineRewrite(HtmlCharactersNode* char_node) { |
| ResourcePtr input_resource(MakeInlineResource(char_node->contents())); |
| ResourceSlotPtr slot(driver()->GetInlineSlot(input_resource, char_node)); |
| |
| CssFilter::Context* rewriter = StartRewriting(slot); |
| if (rewriter == NULL) { |
| return; |
| } |
| HtmlElement* element = char_node->parent(); |
| rewriter->SetupInlineRewrite(element, char_node); |
| |
| // Get the applicable media and charset. As style elements can't have a |
| // charset attribute pass NULL to GetApplicableCharset instead of 'element'. |
| // If the resulting charset for the style element doesn't agree with that of |
| // the source page, we can't flatten (though that should be impossible since |
| // we only look at meta elements and headers in this case). |
| CssHierarchy* hierarchy = rewriter->mutable_hierarchy(); |
| GetApplicableMedia(element, hierarchy->mutable_media()); |
| GoogleString failure_reason; |
| hierarchy->set_flattening_succeeded( |
| GetApplicableCharset(NULL, hierarchy->mutable_charset(), |
| &failure_reason)); |
| if (!hierarchy->flattening_succeeded()) { |
| num_flatten_imports_charset_mismatch_->Add(1); |
| hierarchy->AddFlatteningFailureReason(failure_reason); |
| } |
| } |
| |
| void CssFilter::StartAttributeRewrite(HtmlElement* element, |
| HtmlElement::Attribute* style, |
| InlineCssKind inline_css_kind) { |
| ResourcePtr input_resource(MakeInlineResource(style->DecodedValueOrNull())); |
| ResourceSlotPtr slot( |
| driver()->GetInlineAttributeSlot(input_resource, element, style)); |
| |
| CssFilter::Context* rewriter = StartRewriting(slot); |
| if (rewriter == NULL) { |
| return; |
| } |
| rewriter->SetupAttributeRewrite(element, style, inline_css_kind); |
| |
| // @import is not allowed (nor handled) in attribute CSS, which must be |
| // declarations only, so disable flattening from the get-go. Since this |
| // is not a failure to flatten as such, don't update the statistics. |
| // Not setting the failure reason suppresses +debug from emitting it. |
| rewriter->mutable_hierarchy()->set_flattening_succeeded(false); |
| } |
| |
| void CssFilter::StartExternalRewrite(HtmlElement* link, |
| HtmlElement::Attribute* src) { |
| if (!driver()->can_rewrite_resources()) { |
| return; |
| } |
| // Create the input resource for the slot. |
| ResourcePtr input_resource(CreateInputResourceOrInsertDebugComment( |
| src->DecodedValueOrNull(), link)); |
| if (input_resource.get() == NULL) { |
| return; |
| } |
| ResourceSlotPtr slot(driver()->GetSlot(input_resource, link, src)); |
| CssFilter::Context* rewriter = StartRewriting(slot); |
| if (rewriter == NULL) { |
| return; |
| } |
| GoogleUrl input_resource_gurl(input_resource->url()); |
| // TODO(sligocki): I don't think css_trim_gurl_ should be set to |
| // decoded_base_url(). But I also think that the values passed in here |
| // will always be overwritten later. This should be cleaned up. |
| rewriter->SetupExternalRewrite(link, input_resource_gurl, decoded_base_url()); |
| |
| // Get the applicable media and charset. If the charset on the link doesn't |
| // agree with that of the source page, we can't flatten. |
| CssHierarchy* hierarchy = rewriter->mutable_hierarchy(); |
| GetApplicableMedia(link, hierarchy->mutable_media()); |
| GoogleString failure_reason; |
| hierarchy->set_flattening_succeeded( |
| GetApplicableCharset(link, hierarchy->mutable_charset(), |
| &failure_reason)); |
| if (!hierarchy->flattening_succeeded()) { |
| num_flatten_imports_charset_mismatch_->Add(1); |
| hierarchy->AddFlatteningFailureReason(failure_reason); |
| } |
| } |
| |
| ResourcePtr CssFilter::MakeInlineResource(StringPiece content) { |
| GoogleString data_url; |
| // TODO(morlovich): This does a lot of useless conversions and |
| // copying. Get rid of them. |
| DataUrl(kContentTypeCss, PLAIN, content, &data_url); |
| return DataUrlInputResource::Make(data_url, driver()); |
| } |
| |
| CssFilter::Context* CssFilter::StartRewriting(const ResourceSlotPtr& slot) { |
| // Create the context add it to the slot, then kick everything off. |
| DCHECK(driver()->can_rewrite_resources()); |
| CssFilter::Context* rewriter = MakeContext(driver(), NULL); |
| rewriter->AddSlot(slot); |
| if (driver()->options()->css_preserve_urls()) { |
| slot->set_preserve_urls(true); |
| } |
| if (!driver()->InitiateRewrite(rewriter)) { |
| rewriter = NULL; |
| } |
| return rewriter; |
| } |
| |
| bool CssFilter::GetApplicableCharset(const HtmlElement* element, |
| GoogleString* charset, |
| GoogleString* failure_reason) const { |
| // HTTP1.1 says the default charset is ISO-8859-1 but as the W3C says (in |
| // http://www.w3.org/International/O-HTTP-charset.en.php) not many browsers |
| // actually do this so a default of "" might be better. Starting from that |
| // base, if the headers specify a charset that is used, otherwise if a meta |
| // tag specifies a charset that is used. |
| StringPiece our_charset("iso-8859-1"); |
| const char* our_charset_source = "the default"; |
| GoogleString headers_charset; |
| const ResponseHeaders* headers = driver()->response_headers(); |
| if (headers != NULL) { |
| headers_charset = headers->DetermineCharset(); |
| if (!headers_charset.empty()) { |
| our_charset = headers_charset; |
| our_charset_source = "from headers"; |
| } |
| } |
| if (headers_charset.empty() && !meta_tag_charset_.empty()) { |
| our_charset = meta_tag_charset_; |
| our_charset_source = "from a meta tag"; |
| } |
| if (element != NULL) { |
| const HtmlElement::Attribute* charset_attribute = |
| element->FindAttribute(HtmlName::kCharset); |
| if (charset_attribute != NULL) { |
| const char* elements_charset = charset_attribute->DecodedValueOrNull(); |
| if (our_charset != elements_charset) { |
| *failure_reason = StrCat( |
| "The charset of the HTML (", our_charset, ", ", our_charset_source, |
| ") is different from the charset attribute on the preceding " |
| "element (", |
| (elements_charset == NULL ? "not set" : elements_charset), ")"); |
| return false; // early return! |
| } |
| } |
| } |
| our_charset.CopyToString(charset); |
| return true; |
| } |
| |
| bool CssFilter::GetApplicableMedia(const HtmlElement* element, |
| StringVector* media) const { |
| bool result = false; |
| if (element != NULL) { |
| const HtmlElement::Attribute* media_attribute = |
| element->FindAttribute(HtmlName::kMedia); |
| if (media_attribute != NULL) { |
| css_util::VectorizeMediaAttribute(media_attribute->DecodedValueOrNull(), |
| media); |
| result = true; |
| } |
| } |
| return result; |
| } |
| |
| CssFilter::Context* CssFilter::MakeContext(RewriteDriver* driver, |
| RewriteContext* parent) { |
| ResourceContext* resource_context = new ResourceContext; |
| if (parent != NULL && parent->resource_context() != NULL) { |
| resource_context->CopyFrom(*(parent->resource_context())); |
| } else { |
| EncodeUserAgentIntoResourceContext(resource_context); |
| } |
| return new Context(this, driver, parent, cache_extender_, |
| image_rewrite_filter_, image_combiner_, resource_context); |
| } |
| |
| RewriteContext* CssFilter::MakeRewriteContext() { |
| return MakeContext(driver(), NULL); |
| } |
| |
| const UrlSegmentEncoder* CssFilter::encoder() const { |
| return &encoder_; |
| } |
| |
| void CssFilter::EncodeUserAgentIntoResourceContext( |
| ResourceContext* context) const { |
| // Use the same encoding as the image rewrite filter. |
| image_rewrite_filter_->EncodeUserAgentIntoResourceContext(context); |
| } |
| |
| const UrlSegmentEncoder* CssFilter::Context::encoder() const { |
| return filter_->encoder(); |
| } |
| |
| RewriteContext* CssFilter::MakeNestedRewriteContext( |
| RewriteContext* parent, const ResourceSlotPtr& slot) { |
| RewriteContext* context = MakeContext(NULL, parent); |
| context->AddSlot(slot); |
| return context; |
| } |
| |
| RewriteContext* CssFilter::MakeNestedFlatteningContextInNewSlot( |
| const ResourcePtr& resource, const GoogleString& location, |
| CssFilter::Context* rewriter, RewriteContext* parent, |
| CssHierarchy* hierarchy) { |
| // Slot represents the @import URL inside another CSS file. But rendering is |
| // complicated, so we use a NullResourceSlot that has an empty Render method. |
| ResourceSlotPtr slot(new NullResourceSlot(resource, location)); |
| RewriteContext* context = new CssFlattenImportsContext(parent, this, |
| rewriter, hierarchy); |
| context->AddSlot(slot); |
| return context; |
| } |
| |
| } // namespace net_instaweb |
