| /* |
| * Copyright 2011 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_image_rewriter.h" |
| |
| #include <cstddef> |
| #include <map> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/logging.h" |
| #include "net/instaweb/rewriter/cached_result.pb.h" |
| #include "net/instaweb/rewriter/public/cache_extender.h" |
| #include "net/instaweb/rewriter/public/css_filter.h" |
| #include "net/instaweb/rewriter/public/css_hierarchy.h" |
| #include "net/instaweb/rewriter/public/css_resource_slot.h" |
| #include "net/instaweb/rewriter/public/image_combine_filter.h" |
| #include "net/instaweb/rewriter/public/image_rewrite_filter.h" |
| #include "net/instaweb/rewriter/public/resource.h" |
| #include "net/instaweb/rewriter/public/resource_slot.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 "pagespeed/kernel/base/message_handler.h" |
| #include "pagespeed/kernel/base/string.h" |
| #include "pagespeed/kernel/base/string_util.h" // for StrCat |
| #include "pagespeed/kernel/http/google_url.h" |
| #include "util/utf8/public/unicodetext.h" |
| #include "webutil/css/parser.h" |
| #include "webutil/css/property.h" |
| #include "webutil/css/value.h" |
| |
| |
| namespace net_instaweb { |
| |
| namespace { |
| |
| GoogleString CannotImportMessage(StringPiece action, StringPiece url, |
| bool is_authorized) { |
| return StrCat("Cannot ", action, " ", url, |
| (is_authorized |
| ? " for an unknown reason" |
| : " as it is on an unauthorized domain")); |
| } |
| |
| } // namespace |
| |
| CssImageRewriter::CssImageRewriter(CssFilter::Context* root_context, |
| CssFilter* filter, |
| CacheExtender* cache_extender, |
| ImageRewriteFilter* image_rewriter, |
| ImageCombineFilter* image_combiner) |
| : filter_(filter), |
| root_context_(root_context), |
| // For now we use the same options as for rewriting and cache-extending |
| // images found in HTML. |
| cache_extender_(cache_extender), |
| image_combiner_(image_combiner), |
| image_rewriter_(image_rewriter) { |
| // TODO(morlovich): Unlike the original CssImageRewriter, this uses the same |
| // statistics as underlying filters like CacheExtender. Should it get separate |
| // stats instead? sligocki thinks it's useful to know how many images were |
| // optimized from CSS files, but people probably also want to know how many |
| // total images were cache-extended. |
| } |
| |
| CssImageRewriter::~CssImageRewriter() {} |
| |
| bool CssImageRewriter::RewritesEnabled( |
| int64 image_inline_max_bytes) const { |
| const RewriteOptions* options = driver()->options(); |
| return (image_inline_max_bytes > 0 || |
| options->ImageOptimizationEnabled() || |
| options->Enabled(RewriteOptions::kLeftTrimUrls) || |
| options->Enabled(RewriteOptions::kExtendCacheImages) || |
| options->Enabled(RewriteOptions::kSpriteImages)); |
| } |
| |
| bool CssImageRewriter::RewriteImport(RewriteContext* parent, |
| CssHierarchy* hierarchy, |
| bool* is_authorized) { |
| GoogleUrl import_url(hierarchy->url()); |
| ResourcePtr resource = driver()->CreateInputResource(import_url, |
| is_authorized); |
| if (resource.get() == NULL) { |
| return false; |
| } |
| |
| parent->AddNestedContext( |
| filter_->MakeNestedFlatteningContextInNewSlot( |
| resource, driver()->UrlLine(), root_context_, parent, hierarchy)); |
| return true; |
| } |
| |
| bool CssImageRewriter::RewriteImage(int64 image_inline_max_bytes, |
| const GoogleUrl& trim_url, |
| const GoogleUrl& original_url, |
| RewriteContext* parent, |
| Css::Values* values, |
| size_t value_index, |
| bool* is_authorized) { |
| const RewriteOptions* options = driver()->options(); |
| ResourcePtr resource = driver()->CreateInputResource(original_url, |
| is_authorized); |
| if (resource.get() == NULL) { |
| return false; |
| } |
| |
| CssResourceSlotPtr slot( |
| root_context_->slot_factory()->GetSlot(resource, trim_url, options, |
| values, value_index)); |
| if (options->image_preserve_urls()) { |
| slot->set_preserve_urls(true); |
| } |
| |
| RewriteSlot(ResourceSlotPtr(slot), image_inline_max_bytes, parent); |
| return true; |
| } |
| |
| void CssImageRewriter::RewriteSlot(const ResourceSlotPtr& slot, |
| int64 image_inline_max_bytes, |
| RewriteContext* parent) { |
| const RewriteOptions* options = driver()->options(); |
| if (options->ImageOptimizationEnabled() || image_inline_max_bytes > 0) { |
| // Do not rewrite external resource if preserve_urls is enabled unless |
| // we allow preemptive rewriting. |
| if (!slot->preserve_urls() || |
| options->in_place_preemptive_rewrite_css_images()) { |
| parent->AddNestedContext( |
| image_rewriter_->MakeNestedRewriteContextForCss( |
| image_inline_max_bytes, parent, slot)); |
| } |
| } |
| |
| if (driver()->MayCacheExtendImages()) { |
| parent->AddNestedContext( |
| cache_extender_->MakeNestedContext(parent, slot)); |
| } |
| |
| // TODO(sligocki): DomainRewriter or is this done automatically? |
| } |
| |
| void CssImageRewriter::InheritChildImageInfo(RewriteContext* context) { |
| typedef ImageRewriteFilter::AssociatedImageInfoMap AssociatedImageInfoMap; |
| if (!context->Driver()->options()->Enabled( |
| RewriteOptions::kExperimentCollectMobImageInfo)) { |
| return; |
| } |
| |
| if (context->num_outputs() != 1) { |
| LOG(DFATAL) << "InheritChildImageInfo on context with wrong # of outputs:" |
| << context->num_outputs(); |
| return; |
| } |
| |
| AssociatedImageInfoMap child_image_info; |
| for (int i = 0; i < context->num_nested(); ++i) { |
| RewriteContext* nested_context = context->nested(i); |
| for (int j = 0; j < nested_context->num_output_partitions(); ++j) { |
| const CachedResult* child_result = nested_context->output_partition(j); |
| |
| // Image info may be directly included inside the CachedResult, if |
| // child_result came from the image filter. |
| AssociatedImageInfo from_image_filter; |
| if (ImageRewriteFilter::ExtractAssociatedImageInfo(child_result, |
| nested_context, |
| &from_image_filter)) { |
| child_image_info[from_image_filter.url()] = from_image_filter; |
| } |
| |
| // Info on multiple images may be stored as AssociatedImageInfo by CSS |
| // rewriting or flattening. |
| for (int k = 0; k < child_result->associated_image_info_size(); ++k) { |
| const AssociatedImageInfo& image_info = |
| child_result->associated_image_info(k); |
| child_image_info[image_info.url()] = image_info; |
| } |
| } |
| } |
| |
| for (AssociatedImageInfoMap::iterator i = child_image_info.begin(), |
| e = child_image_info.end(); |
| i != e; ++i) { |
| *context->output_partition(0)->add_associated_image_info() = i->second; |
| } |
| } |
| |
| bool CssImageRewriter::RewriteCss(int64 image_inline_max_bytes, |
| RewriteContext* parent, |
| CssHierarchy* hierarchy, |
| MessageHandler* handler) { |
| const RewriteOptions* options = driver()->options(); |
| bool spriting_ok = options->Enabled(RewriteOptions::kSpriteImages); |
| |
| if (!driver()->FlattenCssImportsEnabled()) { |
| // If flattening is disabled completely, mark this hierarchy as having |
| // failed flattening, so that later RollUps do the right thing (nothing). |
| // This is not something we need to log in the statistics or in debug. |
| hierarchy->set_flattening_succeeded(false); |
| } else if (hierarchy->flattening_succeeded()) { |
| // Flattening of this hierarchy might have already failed because of a |
| // problem detected with the containing charset or media, in particular |
| // see CssFilter::Start(Inline|Attribute|External)Rewrite. |
| if (hierarchy->ExpandChildren()) { |
| for (int i = 0, n = hierarchy->children().size(); i < n; ++i) { |
| CssHierarchy* child = hierarchy->children()[i]; |
| if (child->NeedsRewriting()) { |
| bool is_authorized; |
| if (!RewriteImport(parent, child, &is_authorized)) { |
| hierarchy->set_flattening_succeeded(false); |
| hierarchy->AddFlatteningFailureReason( |
| CannotImportMessage("import", child->url_for_humans(), |
| is_authorized)); |
| } |
| } |
| } |
| } |
| } |
| |
| // TODO(jkarlin): We need a separate flag for CssImagePreserveURLs in case the |
| // user is willing to change image URLs in CSS but not in HTML. |
| bool is_enabled = RewritesEnabled(image_inline_max_bytes); |
| |
| if (is_enabled) { |
| if (spriting_ok) { |
| image_combiner_->Reset(parent, hierarchy->css_base_url(), |
| hierarchy->input_contents()); |
| } |
| Css::Rulesets& rulesets = |
| hierarchy->mutable_stylesheet()->mutable_rulesets(); |
| for (Css::Rulesets::iterator ruleset_iter = rulesets.begin(); |
| ruleset_iter != rulesets.end(); ++ruleset_iter) { |
| Css::Ruleset* ruleset = *ruleset_iter; |
| if (ruleset->type() != Css::Ruleset::RULESET) { |
| continue; |
| } |
| Css::Declarations& decls = ruleset->mutable_declarations(); |
| bool background_position_found = false; |
| bool background_image_found = false; |
| for (Css::Declarations::iterator decl_iter = decls.begin(); |
| decl_iter != decls.end(); ++decl_iter) { |
| Css::Declaration* decl = *decl_iter; |
| // Only edit image declarations. |
| switch (decl->prop()) { |
| case Css::Property::BACKGROUND_POSITION: |
| case Css::Property::BACKGROUND_POSITION_X: |
| case Css::Property::BACKGROUND_POSITION_Y: |
| background_position_found = true; |
| break; |
| case Css::Property::BACKGROUND: |
| case Css::Property::BACKGROUND_IMAGE: |
| case Css::Property::CONTENT: // In CSS2 but not CSS2.1 |
| case Css::Property::CURSOR: |
| case Css::Property::LIST_STYLE: |
| case Css::Property::LIST_STYLE_IMAGE: { |
| // Rewrite all URLs. Technically, background-image should only |
| // have a single value which is a URL, but background could have |
| // more values. |
| Css::Values* values = decl->mutable_values(); |
| for (size_t value_index = 0; value_index < values->size(); |
| value_index++) { |
| Css::Value* value = values->at(value_index); |
| if (value->GetLexicalUnitType() == Css::Value::URI) { |
| background_image_found = true; |
| GoogleString rel_url = |
| UnicodeTextToUTF8(value->GetStringValue()); |
| // TODO(abliss): only do this resolution once. |
| const GoogleUrl original_url(hierarchy->css_resolution_base(), |
| rel_url); |
| if (!original_url.IsWebValid()) { |
| continue; |
| } |
| if (!options->IsAllowed(original_url.Spec())) { |
| continue; |
| } |
| bool is_authorized; |
| if (spriting_ok) { |
| // TODO(sligocki): Pass in the correct base URL here. |
| // Specifically, the final base URL of the CSS that will |
| // be used to trim the final URLs. |
| // hierarchy->css_base_url(), hierarchy->css_trim_url(), |
| // or hierarchy->css_resolution_base()? |
| // Note that currently preserving URLs doesn't work for |
| // image combining filter, so we need to fix that before |
| // testing which URL is correct. |
| if (!image_combiner_->AddCssBackgroundContext( |
| original_url, hierarchy->css_trim_url(), |
| values, value_index, root_context_, &decls, |
| &is_authorized, handler)) { |
| // This doesn't fail flattening but we want to log it. |
| hierarchy->AddFlatteningFailureReason( |
| CannotImportMessage("rewrite", original_url.Spec(), |
| is_authorized)); |
| } |
| } |
| if (!RewriteImage(image_inline_max_bytes, |
| hierarchy->css_trim_url(), original_url, |
| parent, values, value_index, |
| &is_authorized)) { |
| // This doesn't fail flattening but we want to log it. |
| hierarchy->AddFlatteningFailureReason( |
| CannotImportMessage("rewrite", original_url.Spec(), |
| is_authorized)); |
| } |
| } |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| // All the declarations in this ruleset have been parsed. |
| if (spriting_ok && background_position_found && !background_image_found) { |
| // A ruleset that contains a background-position but no background image |
| // is a signal that we should not be spriting. |
| handler->Message(kInfo, |
| "Lone background-position found: Cannot sprite."); |
| spriting_ok = false; |
| } |
| } |
| |
| image_combiner_->RegisterOrReleaseContext(); |
| } else { |
| handler->Message(kInfo, "Image rewriting and cache extension not enabled, " |
| "so not rewriting images in CSS in %s", |
| hierarchy->css_base_url().spec_c_str()); |
| } |
| |
| return is_enabled; |
| } |
| |
| } // namespace net_instaweb |
