resource_slot.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_RESOURCE_SLOT_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_RESOURCE_SLOT_H_

#include <memory>
#include <set>
#include <vector>

#include "net/instaweb/rewriter/input_info.pb.h"
#include "net/instaweb/rewriter/public/resource.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/ref_counted_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/vector_deque.h"
#include "pagespeed/kernel/html/html_element.h"
#include "pagespeed/kernel/http/google_url.h"

namespace net_instaweb {

class HtmlResourceSlot;
class ResourceSlot;
class RewriteContext;
class RewriteDriver;
class RewriteOptions;

typedef RefCountedPtr<ResourceSlot> ResourceSlotPtr;
typedef RefCountedPtr<HtmlResourceSlot> HtmlResourceSlotPtr;
typedef std::vector<ResourceSlotPtr> ResourceSlotVector;

class ResourceSlot : public RefCounted<ResourceSlot> {
 public:
  explicit ResourceSlot(const ResourcePtr& resource)
      : resource_(resource),
        preserve_urls_(false),
        disable_rendering_(false),
        should_delete_element_(false),
        disable_further_processing_(false),
        was_optimized_(false),
        need_aggregate_input_info_(false) {
  }

  ResourcePtr resource() const { return resource_; }
  virtual HtmlElement* element() const = 0;

  void SetResource(const ResourcePtr& resource);

  void set_preserve_urls(bool x) { preserve_urls_ = x; }
  bool preserve_urls() const { return preserve_urls_; }

  void set_disable_rendering(bool x) { disable_rendering_ = x; }
  bool disable_rendering() const { return disable_rendering_; }

  void RequestDeleteElement() {
    should_delete_element_ = true;
    disable_further_processing_ = true;
  }
  bool should_delete_element() const { return should_delete_element_; }

  bool was_optimized() const { return was_optimized_; }

  void set_was_optimized(bool x) { was_optimized_ = x; }

  void set_disable_further_processing(bool x) {
    disable_further_processing_ = x;
  }

  bool disable_further_processing() const {
    return disable_further_processing_;
  }

  void set_need_aggregate_input_info(bool x) {
    need_aggregate_input_info_ = x;
  }

  bool need_aggregate_input_info() const {
    return need_aggregate_input_info_;
  }

  void ReportInput(const InputInfo& input);

  const std::vector<InputInfo>* inputs() const { return inputs_.get(); }

  virtual void Render() = 0;

  virtual void Finished() {}

  virtual bool DirectSetUrl(const StringPiece& url);

  virtual bool CanDirectSetUrl() { return false; }

  RewriteContext* LastContext() const;

  void AddContext(RewriteContext* context) { contexts_.push_back(context); }

  void DetachContext(RewriteContext* context);

  virtual GoogleString LocationString() const = 0;

  static GoogleString RelativizeOrPassthrough(const RewriteOptions* options,
                                              StringPiece url,
                                              UrlRelativity url_relativity,
                                              const GoogleUrl& base_url);

 protected:
  virtual ~ResourceSlot();
  REFCOUNT_FRIEND_DECLARATION(ResourceSlot);

 private:
  ResourcePtr resource_;
  std::unique_ptr<std::vector<InputInfo>> inputs_;
  bool preserve_urls_;
  bool disable_rendering_;
  bool should_delete_element_;
  bool disable_further_processing_;
  bool was_optimized_;
  bool need_aggregate_input_info_;

  VectorDeque<RewriteContext*> contexts_;

  
};

class NullResourceSlot : public ResourceSlot {
 public:
  NullResourceSlot(const ResourcePtr& resource, StringPiece location);
  virtual HtmlElement* element() const { return NULL; }
  virtual void Render() {}
  virtual GoogleString LocationString() const { return location_; }

 protected:
  REFCOUNT_FRIEND_DECLARATION(NullResourceSlot);
  virtual ~NullResourceSlot();

 private:
  GoogleString location_;

  
};

class FetchResourceSlot : public ResourceSlot {
 public:
  explicit FetchResourceSlot(const ResourcePtr& resource)
      : ResourceSlot(resource) {
  }
  virtual HtmlElement* element() const { return NULL; }
  virtual void Render();
  virtual GoogleString LocationString() const;

 protected:
  REFCOUNT_FRIEND_DECLARATION(FetchResourceSlot);
  virtual ~FetchResourceSlot();

 private:
  
};

class HtmlResourceSlot : public ResourceSlot {
 public:
  HtmlResourceSlot(const ResourcePtr& resource,
                   HtmlElement* element,
                   HtmlElement::Attribute* attribute,
                   RewriteDriver* driver);

  virtual HtmlElement* element() const { return element_; }
  HtmlElement::Attribute* attribute() const { return attribute_; }

  virtual void Render();
  virtual GoogleString LocationString() const;
  virtual bool DirectSetUrl(const StringPiece& url);
  virtual bool CanDirectSetUrl() { return true; }

  UrlRelativity url_relativity() const { return url_relativity_; }

 protected:
  REFCOUNT_FRIEND_DECLARATION(HtmlResourceSlot);
  virtual ~HtmlResourceSlot();

 private:
  HtmlElement* element_;
  HtmlElement::Attribute* attribute_;
  RewriteDriver* driver_;
  UrlRelativity url_relativity_;

  int begin_line_number_;
  int end_line_number_;

  
};

class HtmlResourceSlotComparator {
 public:
  bool operator()(const HtmlResourceSlotPtr& p,
                  const HtmlResourceSlotPtr& q) const;
};

typedef std::set<HtmlResourceSlotPtr,
                 HtmlResourceSlotComparator> HtmlResourceSlotSet;

}  

#endif