in_place_rewrite_context.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_IN_PLACE_REWRITE_CONTEXT_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_IN_PLACE_REWRITE_CONTEXT_H_

#include "net/instaweb/http/public/async_fetch.h"
#include "net/instaweb/http/public/http_value.h"
#include "net/instaweb/http/public/http_value_writer.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_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/proto_util.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/content_type.h"

namespace net_instaweb {

class CachedResult;
class CacheUrlAsyncFetcher;
class HtmlElement;
class InputInfo;
class MessageHandler;
class ResourceContext;
class ResponseHeaders;
class RewriteDriver;
class RewriteFilter;
class Statistics;
class Variable;

class InPlaceRewriteResourceSlot : public ResourceSlot {
 public:
  static const char kIproSlotLocation[];
  explicit InPlaceRewriteResourceSlot(const ResourcePtr& resource);

  virtual HtmlElement* element() const { return NULL; }

  virtual void Render();

  virtual GoogleString LocationString() const;

 protected:
  virtual ~InPlaceRewriteResourceSlot();

 private:
  
};

class InPlaceRewriteContext : public SingleRewriteContext {
 public:
  static const char kInPlaceOversizedOptStream[];
  static const char kInPlaceUncacheableRewrites[];

  InPlaceRewriteContext(RewriteDriver* driver, const StringPiece& url);
  virtual ~InPlaceRewriteContext();

  virtual void RewriteSingle(const ResourcePtr& input,
                             const OutputResourcePtr& output);
  virtual const char* id() const { return RewriteOptions::kInPlaceRewriteId; }
  virtual OutputResourceKind kind() const { return kRewrittenResource; }
  virtual bool DecodeFetchUrls(const OutputResourcePtr& output_resource,
                               MessageHandler* message_handler,
                               GoogleUrlStarVector* url_vector);
  virtual void StartFetchReconstruction();

  static void InitStats(Statistics* statistics);

  bool proxy_mode() const { return proxy_mode_; }
  void set_proxy_mode(bool x) { proxy_mode_ = x; }

  virtual int64 GetRewriteDeadlineAlarmMs() const;

  virtual GoogleString UserAgentCacheKey(
      const ResourceContext* resource_context) const;
  virtual void EncodeUserAgentIntoResourceContext(ResourceContext* context);

  virtual bool CreationLockBeforeStartFetch() const { return false; }

  bool ScheduleNestedContextViaCentalController() const override {
    return true;
  }

 private:
  friend class RecordingFetch;
  bool PolicyPermitsRendering() const override;
  virtual void Harvest();
  void StartFetchReconstructionParent();
  virtual void FixFetchFallbackHeaders(const CachedResult& cached_result,
                                       ResponseHeaders* headers);
  virtual void FetchTryFallback(const GoogleString& url,
                                const StringPiece& hash);
  virtual void FetchCallbackDone(bool success);

  RewriteFilter* GetRewriteFilter(const ContentType& type);

  void UpdateDateAndExpiry(const protobuf::RepeatedPtrField<InputInfo>& inputs,
                           int64* date_ms, int64* expiry_ms);
  bool InPlaceOptimizeForBrowserEnabled() const;
  void AddVaryIfRequired(const CachedResult& cached_result,
                         ResponseHeaders* headers) const;
  void RemoveRedundantRelCanonicalHeader(const CachedResult& cached_result,
                                         ResponseHeaders* headers);

  bool IsLoadFromFileBased();

  GoogleString url_;
  bool is_rewritten_;
  GoogleString rewritten_hash_;

  ResourcePtr input_resource_;
  OutputResourcePtr output_resource_;

  scoped_ptr<CacheUrlAsyncFetcher> cache_fetcher_;

  bool proxy_mode_;

  
};

class RecordingFetch : public SharedAsyncFetch {
 public:
  RecordingFetch(bool proxy_mode,
                 AsyncFetch* async_fetch,
                 const ResourcePtr& resource,
                 InPlaceRewriteContext* context,
                 int desired_s_maxage_sec,
                 MessageHandler* handler);

  virtual ~RecordingFetch();

  virtual void HandleHeadersComplete();
  virtual bool HandleWrite(const StringPiece& content, MessageHandler* handler);
  virtual bool HandleFlush(MessageHandler* handler);
  virtual void HandleDone(bool success);

 private:
  void FreeDriver();

  bool CanInPlaceRewrite();

  bool ShouldStream() const;

  bool proxy_mode_;
  MessageHandler* handler_;
  ResourcePtr resource_;
  InPlaceRewriteContext* context_;

  int desired_s_maxage_sec_;

  bool can_in_place_rewrite_;

  bool streaming_;
  HTTPValue cache_value_;
  HTTPValueWriter cache_value_writer_;
  scoped_ptr<ResponseHeaders> saved_headers_;
  Variable* in_place_oversized_opt_stream_;
  Variable* in_place_uncacheable_rewrites_;
  
};

}  

#endif