resource.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_RESOURCE_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_RESOURCE_H_

#include <vector>

#include "base/logging.h"
#include "net/instaweb/http/public/http_cache_failure.h"
#include "net/instaweb/http/public/http_value.h"
#include "net/instaweb/http/public/request_context.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/callback.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/http/content_type.h"
#include "pagespeed/kernel/http/http_names.h"
#include "pagespeed/kernel/http/response_headers.h"

namespace net_instaweb {

class CachedResult;
class GoogleUrl;
class InputInfo;
class MessageHandler;
class Resource;
class RewriteDriver;
class ServerContext;

typedef RefCountedPtr<Resource> ResourcePtr;
typedef std::vector<ResourcePtr> ResourceVector;

class Resource : public RefCounted<Resource> {
 public:
  class AsyncCallback;

  enum HashHint {
    kOmitInputHash,
    kIncludeInputHash
  };

  enum NotCacheablePolicy {
    kLoadEvenIfNotCacheable,
    kReportFailureIfNotCacheable,
  };


  Resource(const RewriteDriver* driver, const ContentType* type);

  ServerContext* server_context() const { return server_context_; }

  virtual bool IsValidAndCacheable() const;

  bool is_authorized_domain() { return is_authorized_domain_; }
  void set_is_authorized_domain(bool is_authorized) {
    is_authorized_domain_ = is_authorized;
  }

  bool IsSafeToRewrite(bool rewrite_uncacheable, GoogleString* reason) const;
  bool IsSafeToRewrite(bool rewrite_uncacheable) const {
    GoogleString reason_ignored;
    return IsSafeToRewrite(rewrite_uncacheable, &reason_ignored);
  }

  bool loaded() const { return response_headers_.status_code() != 0; }
  bool HttpStatusOk() const {
    return (response_headers_.status_code() == HttpStatus::kOK);
  }

  void LoadAsync(NotCacheablePolicy not_cacheable_policy,
                 const RequestContextPtr& request_context,
                 AsyncCallback* callback);

  virtual void RefreshIfImminentlyExpiring();

  GoogleString ContentsHash() const;

  void AddInputInfoToPartition(HashHint suggest_include_content_hash,
                               int index, CachedResult* partition);

  virtual void FillInPartitionInputInfo(HashHint suggest_include_content_hash,
                                        InputInfo* input);

  void FillInPartitionInputInfoFromResponseHeaders(
      const ResponseHeaders& headers,
      InputInfo* input);

  int64 CacheExpirationTimeMs() const;

  StringPiece ExtractUncompressedContents() const;

  size_t UncompressedContentsSize() const {
    StringPiece val = ExtractUncompressedContents();
    return val.length();
  }

  StringPiece raw_contents() const {
    StringPiece val;
    bool got_contents = value_.ExtractContents(&val);
    CHECK(got_contents) << "Resource contents read before loading: "
                        << UrlForDebug();
    return val;
  }

  ResponseHeaders* response_headers() { return &response_headers_; }
  const ResponseHeaders* response_headers() const { return &response_headers_; }
  const ContentType* type() const { return type_; }
  virtual void SetType(const ContentType* type);
  bool IsContentsEmpty() const {
    return raw_contents().empty();
  }

  StringPiece charset() const { return charset_; }
  void set_charset(StringPiece c) { c.CopyToString(&charset_); }

  virtual GoogleString url() const = 0;
  virtual bool has_url() const { return true; }
  virtual GoogleString UrlForDebug() const { return url(); }

  virtual GoogleString cache_key() const {
    return url();
  }

  void DetermineContentType();

  class AsyncCallback {
   public:
    explicit AsyncCallback(const ResourcePtr& resource) : resource_(resource) {}

    virtual ~AsyncCallback();
    virtual void Done(bool lock_failure, bool resource_ok) = 0;

    const ResourcePtr& resource() { return resource_; }

   private:
    ResourcePtr resource_;
    
  };

  class FreshenCallback : public AsyncCallback {
   public:
    explicit FreshenCallback(const ResourcePtr& resource)
        : AsyncCallback(resource) {}

    virtual ~FreshenCallback();
    virtual InputInfo* input_info() { return NULL; }

    virtual void Done(bool lock_failure, bool resource_ok) {
      delete this;
    }

   private:
    
  };

  bool Link(HTTPValue* source, MessageHandler* handler);

  virtual void Freshen(FreshenCallback* callback, MessageHandler* handler);

  void LinkFallbackValue(HTTPValue* value);

  void set_is_background_fetch(bool x) { is_background_fetch_ = x; }
  bool is_background_fetch() const { return is_background_fetch_; }

  FetchResponseStatus fetch_response_status() {
    return fetch_response_status_;
  }

  void set_fetch_response_status(FetchResponseStatus x) {
    fetch_response_status_ = x;
  }

  virtual bool UseHttpCache() const = 0;

 protected:
  virtual ~Resource();
  REFCOUNT_FRIEND_DECLARATION(Resource);
  friend class ServerContext;
  friend class ReadAsyncHttpCacheCallback; 
  friend class RewriteDriver; 
  friend class UrlReadAsyncFetchCallback;

  virtual void LoadAndCallback(NotCacheablePolicy not_cacheable_policy,
                               const RequestContextPtr& request_context,
                               AsyncCallback* callback) = 0;

  void set_enable_cache_purge(bool x) { enable_cache_purge_ = x; }
  ResponseHeaders::VaryOption respect_vary() const { return respect_vary_; }
  void set_respect_vary(ResponseHeaders::VaryOption x) { respect_vary_ = x; }
  void set_proactive_resource_freshening(bool x) {
    proactive_resource_freshening_ = x;
  }

  void set_disable_rewrite_on_no_transform(bool x) {
    disable_rewrite_on_no_transform_ = x;
  }
  ServerContext* server_context_;

  const ContentType* type_;
  GoogleString charset_;
  HTTPValue value_; 
  ResponseHeaders response_headers_;

  HTTPValue fallback_value_;

 private:
  Resource();
  friend class DummyResource;

  FetchResponseStatus fetch_response_status_;

  bool is_background_fetch_;
  bool enable_cache_purge_;
  bool proactive_resource_freshening_;
  bool disable_rewrite_on_no_transform_;
  bool is_authorized_domain_;
  ResponseHeaders::VaryOption respect_vary_;
  mutable GoogleString extracted_contents_;
  mutable bool extracted_;

  
};

typedef Callback2<const GoogleUrl&, bool*> ResourceUrlClaimant;

}  

#endif