css_hierarchy.h

Go to the documentation of this file.

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


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_CSS_HIERARCHY_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_CSS_HIERARCHY_H_

#include <vector>

#include "net/instaweb/rewriter/public/resource.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/http/data_url.h"
#include "pagespeed/kernel/http/google_url.h"

namespace Css {
class Stylesheet;
}  

namespace net_instaweb {

class CssFilter;
class MessageHandler;

class CssHierarchy {
 public:
  static const char kFailureReasonPrefix[];

  explicit CssHierarchy(CssFilter* filter);
  ~CssHierarchy();

  void InitializeRoot(const GoogleUrl& css_base_url,
                      const GoogleUrl& css_trim_url,
                      const StringPiece input_contents,
                      bool has_unparseables,
                      int64 flattened_result_limit,
                      Css::Stylesheet* stylesheet,
                      MessageHandler* message_handler);

  bool NeedsRewriting() const {
    return flattening_succeeded_ && !url_.empty();
  }

  const StringPiece url() const { return url_; }
  const StringPiece url_for_humans() const {
    return (url_.empty() ? "inline"
            : IsDataUrl(url_) ? "data URL"
            : url_);
  }

  const GoogleUrl& css_base_url() const { return css_base_url_; }
  const GoogleUrl& css_trim_url() const { return css_trim_url_; }

  const GoogleUrl& css_resolution_base() {
    return (input_contents_resolved_ ? css_trim_url_ : css_base_url_);
  }

  const Css::Stylesheet* stylesheet() const { return stylesheet_.get(); }
  Css::Stylesheet* mutable_stylesheet() { return stylesheet_.get(); }
  void set_stylesheet(Css::Stylesheet* stylesheet);

  const StringPiece input_contents() const { return input_contents_; }
  void set_input_contents(const StringPiece input_contents) {
    input_contents_ = input_contents;
  }

  GoogleString* input_contents_backing_store() {
    return &input_contents_backing_store_;
  }
  void set_input_contents_to_backing_store() {
    input_contents_ = input_contents_backing_store_;
  }

  const GoogleString& minified_contents() const { return minified_contents_; }
  void set_minified_contents(const StringPiece minified_contents);

  const GoogleString& charset() const { return charset_; }
  GoogleString* mutable_charset() { return &charset_; }

  const GoogleString& charset_source() const { return charset_source_; }

  const StringVector& media() const { return media_; }
  StringVector* mutable_media() { return &media_; }

  const std::vector<CssHierarchy*>& children() const { return children_; }
  std::vector<CssHierarchy*>& children() { return children_; }

  bool input_contents_resolved() const { return input_contents_resolved_; }
  void set_input_contents_resolved(bool x) { input_contents_resolved_ = x; }

  bool flattening_succeeded() const { return flattening_succeeded_; }
  void set_flattening_succeeded(bool ok) { flattening_succeeded_ = ok; }

  const GoogleString& flattening_failure_reason() const {
    return flattening_failure_reason_;
  }
  void AddFlatteningFailureReason(const GoogleString& reason);

  bool unparseable_detected() const { return unparseable_detected_; }
  void set_unparseable_detected(bool ok) { unparseable_detected_ = ok; }

  int64 flattened_result_limit() const { return flattened_result_limit_; }
  void set_flattened_result_limit(int64 x) { flattened_result_limit_ = x; }

  bool CheckCharsetOk(const ResourcePtr& resource,
                      GoogleString* failure_reason);

  bool Parse();

  bool ExpandChildren();

  void RollUpContents();

  bool RollUpStylesheets();

 private:
  friend class CssHierarchyTest;

  void InitializeNested(const CssHierarchy& parent,
                        const GoogleUrl& import_url);

  void ResizeChildren(int n);

  bool IsRecursive() const;

  bool DetermineImportMedia(const StringVector& containing_media,
                            const StringVector& import_media);

  bool DetermineRulesetMedia(StringVector* ruleset_media);

  CssFilter* filter_;

  StringPiece url_;

  GoogleUrl css_base_url_;

  GoogleUrl css_trim_url_;

  const CssHierarchy* parent_;

  std::vector<CssHierarchy*> children_;

  StringPiece input_contents_;

  GoogleString input_contents_backing_store_;

  GoogleString minified_contents_;

  scoped_ptr<Css::Stylesheet> stylesheet_;

  GoogleString charset_;

  GoogleString charset_source_;

  StringVector media_;

  bool input_contents_resolved_;

  bool flattening_succeeded_;

  GoogleString flattening_failure_reason_;

  bool unparseable_detected_;

  int64 flattened_result_limit_;

  MessageHandler* message_handler_;

  
};

}  

#endif