css_filter.h

Go to the documentation of this file.

/*
 * 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.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_CSS_FILTER_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_CSS_FILTER_H_

#include "net/instaweb/rewriter/cached_result.pb.h"
#include "net/instaweb/rewriter/public/css_hierarchy.h"
#include "net/instaweb/rewriter/public/css_resource_slot.h"
#include "net/instaweb/rewriter/public/css_url_encoder.h"
#include "net/instaweb/rewriter/public/output_resource_kind.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_filter.h"
#include "net/instaweb/rewriter/public/rewrite_options.h"
#include "net/instaweb/rewriter/public/server_context.h"
#include "net/instaweb/rewriter/public/single_rewrite_context.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/html/html_element.h"
#include "pagespeed/kernel/html/html_node.h"
#include "pagespeed/kernel/http/google_url.h"
#include "pagespeed/kernel/util/url_segment_encoder.h"

namespace Css {

class Stylesheet;

}  

namespace net_instaweb {

class AssociationTransformer;
class AsyncFetch;
class CssImageRewriter;
class CacheExtender;
class ImageCombineFilter;
class ImageRewriteFilter;
class MessageHandler;
class RewriteDomainTransformer;
class Statistics;
class UpDownCounter;
class Variable;

class CssFilter : public RewriteFilter {
 public:
  class Context;

  CssFilter(RewriteDriver* driver,
            CacheExtender* cache_extender,
            ImageRewriteFilter* image_rewriter,
            ImageCombineFilter* image_combiner);
  virtual ~CssFilter();

  static void InitStats(Statistics* statistics);

  static void Initialize();
  static void Terminate();

  static void AddRelatedOptions(StringPieceVector* target);

  virtual void StartDocumentImpl();
  virtual void StartElementImpl(HtmlElement* element);
  virtual void Characters(HtmlCharactersNode* characters);
  virtual void EndElementImpl(HtmlElement* element);

  virtual const char* Name() const { return "CssFilter"; }
  virtual const char* id() const { return RewriteOptions::kCssFilterId; }
  virtual void EncodeUserAgentIntoResourceContext(
      ResourceContext* context) const;

  static const char kBlocksRewritten[];
  static const char kParseFailures[];
  static const char kFallbackRewrites[];
  static const char kFallbackFailures[];
  static const char kRewritesDropped[];
  static const char kTotalBytesSaved[];
  static const char kTotalOriginalBytes[];
  static const char kUses[];
  static const char kCharsetMismatch[];
  static const char kInvalidUrl[];
  static const char kLimitExceeded[];
  static const char kMinifyFailed[];
  static const char kRecursion[];
  static const char kComplexQueries[];

  RewriteContext* MakeNestedFlatteningContextInNewSlot(
      const ResourcePtr& resource, const GoogleString& location,
      CssFilter::Context* rewriter, RewriteContext* parent,
      CssHierarchy* hierarchy);

  virtual const RewriteOptions::Filter* RelatedFilters(int* num_filters) const {
    *num_filters = merged_filters_size_;
    return merged_filters_;
  }
  virtual const StringPieceVector* RelatedOptions() const {
    return related_options_;
  }

 protected:
  virtual RewriteContext* MakeRewriteContext();
  virtual const UrlSegmentEncoder* encoder() const;
  virtual RewriteContext* MakeNestedRewriteContext(
      RewriteContext* parent, const ResourceSlotPtr& slot);

 private:
  friend class Context;
  friend class CssFlattenImportsContext; 
  friend class CssHierarchy; 

  enum InlineCssKind {
    kInsideStyleTag,
    kAttributeWithoutUrls,
    kAttributeWithUrls
  };

  Context* MakeContext(RewriteDriver* driver,
                       RewriteContext* parent);

  void StartInlineRewrite(HtmlCharactersNode* text,
                          HtmlElement* parent_element);

  void StartAttributeRewrite(HtmlElement* element,
                             HtmlElement::Attribute* style,
                             InlineCssKind inline_css_kind);

  void StartExternalRewrite(HtmlElement* link, HtmlElement::Attribute* src);

  ResourcePtr MakeInlineResource(StringPiece content);
  CssFilter::Context* StartRewriting(const ResourceSlotPtr& slot);

  bool GetApplicableCharset(const HtmlElement* element,
                            GoogleString* charset,
                            GoogleString* failure_reason) const;

  bool GetApplicableMedia(const HtmlElement* element,
                          StringVector* media) const;

  bool in_style_element_; 
  HtmlElement* style_element_; 

  GoogleString meta_tag_charset_;

  CacheExtender* cache_extender_;
  ImageRewriteFilter* image_rewrite_filter_;
  ImageCombineFilter* image_combiner_;

  Variable* num_blocks_rewritten_;
  Variable* num_parse_failures_;
  Variable* num_fallback_rewrites_;
  Variable* num_fallback_failures_;
  Variable* num_rewrites_dropped_;
  UpDownCounter* total_bytes_saved_;
  Variable* total_original_bytes_;
  Variable* num_uses_;
  Variable* num_flatten_imports_charset_mismatch_;
  Variable* num_flatten_imports_invalid_url_;
  Variable* num_flatten_imports_limit_exceeded_;
  Variable* num_flatten_imports_minify_failed_;
  Variable* num_flatten_imports_recursion_;
  Variable* num_flatten_imports_complex_queries_;

  CssUrlEncoder encoder_;

  static const RewriteOptions::Filter* merged_filters_;
  static int merged_filters_size_;

  static StringPieceVector* related_options_;

  
};

class CssFilter::Context : public SingleRewriteContext {
 public:
  Context(CssFilter* filter, RewriteDriver* driver,
          RewriteContext* parent,
          CacheExtender* cache_extender,
          ImageRewriteFilter* image_rewriter,
          ImageCombineFilter* image_combiner,
          ResourceContext* context);
  virtual ~Context();

  void SetupInlineRewrite(HtmlElement* style_element, HtmlCharactersNode* text);
  void SetupAttributeRewrite(HtmlElement* element,
                             HtmlElement::Attribute* src,
                             InlineCssKind inline_css_kind);
  void SetupExternalRewrite(HtmlElement* element,
                            const GoogleUrl& base_gurl,
                            const GoogleUrl& trim_gurl);

  void RewriteCssFromNested(RewriteContext* parent, CssHierarchy* hierarchy);

  virtual bool SendFallbackResponse(StringPiece output_url_base,
                                    StringPiece input_contents,
                                    AsyncFetch* async_fetch,
                                    MessageHandler* handler);

  CssResourceSlotFactory* slot_factory() { return &slot_factory_; }

  CssHierarchy* mutable_hierarchy() { return &hierarchy_; }

 protected:
  bool PolicyPermitsRendering() const override;
  void Render() override;
  virtual void Harvest();
  virtual bool Partition(OutputPartitions* partitions,
                         OutputResourceVector* outputs);
  virtual void RewriteSingle(const ResourcePtr& input,
                             const OutputResourcePtr& output);
  virtual const char* id() const { return filter_->id(); }
  virtual OutputResourceKind kind() const { return kRewrittenResource; }
  virtual GoogleString CacheKeySuffix() const;
  virtual const UrlSegmentEncoder* encoder() const;

  virtual GoogleString UserAgentCacheKey(
      const ResourceContext* resource_context) const;

 private:
  void GetCssBaseUrlToUse(const ResourcePtr& input_resource,
                          GoogleUrl* css_base_gurl_to_use);

  void GetCssTrimUrlToUse(const ResourcePtr& input_resource,
                          const StringPiece& output_url_base,
                          GoogleUrl* css_base_gurl_to_use);

  void GetCssTrimUrlToUse(const ResourcePtr& input_resource,
                          const OutputResourcePtr& output_resource,
                          GoogleUrl* css_base_gurl_to_use);

  bool 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);

  void RewriteCssFromRoot(const GoogleUrl& css_base_gurl,
                          const GoogleUrl& css_trim_gurl,
                          const StringPiece& in_text, int64 in_text_size,
                          bool has_unparseables, Css::Stylesheet* stylesheet);

  bool FallbackRewriteUrls(const GoogleUrl& css_base_gurl,
                           const GoogleUrl& css_trim_gurl,
                           const StringPiece& in_text);

  bool 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 IsInlineAttribute() const {
    return (rewrite_inline_attribute_ != NULL);
  }

  int64 ImageInlineMaxBytes() const;

  virtual bool ScheduleViaCentralController() { return true; }

  CssFilter* filter_;
  scoped_ptr<CssImageRewriter> css_image_rewriter_;
  ImageRewriteFilter* image_rewrite_filter_;
  CssResourceSlotFactory slot_factory_;
  CssHierarchy hierarchy_;
  bool css_rewritten_;
  bool has_utf8_bom_;

  bool fallback_mode_;
  scoped_ptr<AssociationTransformer> fallback_transformer_;
  scoped_ptr<RewriteDomainTransformer> absolutifier_;

  HtmlElement* rewrite_element_;

  HtmlElement* rewrite_inline_element_;

  HtmlCharactersNode* rewrite_inline_char_node_;

  HtmlElement::Attribute* rewrite_inline_attribute_;

  InlineCssKind rewrite_inline_css_kind_;

  int64 in_text_size_;
  GoogleUrl initial_css_base_gurl_;
  GoogleUrl initial_css_trim_gurl_;
  scoped_ptr<GoogleUrl> base_gurl_for_fallback_;
  scoped_ptr<GoogleUrl> trim_gurl_for_fallback_;
  ResourcePtr input_resource_;
  OutputResourcePtr output_resource_;

  
};

}  

#endif