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

// Author: jmarantz@google.com (Joshua Marantz)

#include "net/instaweb/rewriter/public/cacheable_resource_base.h"

#include "base/logging.h"               // for operator<<, etc
#include "net/instaweb/config/rewrite_options_manager.h"
#include "net/instaweb/http/public/async_fetch.h"
#include "net/instaweb/http/public/async_fetch_with_lock.h"
#include "net/instaweb/http/public/http_cache.h"
#include "net/instaweb/http/public/http_cache_failure.h"
#include "net/instaweb/http/public/http_value.h"
#include "net/instaweb/http/public/http_value_writer.h"
#include "net/instaweb/http/public/url_async_fetcher.h"
#include "net/instaweb/rewriter/cached_result.pb.h"
#include "net/instaweb/rewriter/public/request_properties.h"
#include "net/instaweb/rewriter/public/resource.h"
#include "net/instaweb/rewriter/public/rewrite_driver.h"
#include "net/instaweb/rewriter/public/rewrite_options.h"
#include "net/instaweb/rewriter/public/rewrite_stats.h"
#include "pagespeed/kernel/base/basictypes.h"        // for int64
#include "pagespeed/kernel/base/callback.h"
#include "pagespeed/kernel/base/hasher.h"
#include "pagespeed/kernel/base/statistics.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/timer.h"
#include "pagespeed/kernel/http/google_url.h"
#include "pagespeed/kernel/http/http_names.h"
#include "pagespeed/kernel/http/request_headers.h"
#include "pagespeed/kernel/http/response_headers.h"

namespace net_instaweb {

namespace {

const char kHitSuffix[] = "_hit";
const char kRecentFetchFailureSuffix[] = "_recent_fetch_failure";
const char kRecentUncacheableMiss[] = "_recent_uncacheable_miss";
const char kRecentUncacheableFailure[] = "_recent_uncacheable_failure";
const char kMissSuffix[] = "_miss";

}  // namespace

// Shared base class for fetch callbacks, used by both LoadAndCallback and
// Freshen.
class CacheableResourceBase::FetchCallbackBase : public AsyncFetchWithLock {
 public:
  FetchCallbackBase(ServerContext* server_context,
                    const RewriteOptions* rewrite_options,
                    const GoogleString& url,
                    const GoogleString& cache_key,
                    HTTPValue* fallback_value,
                    const RequestContextPtr& request_context,
                    MessageHandler* handler,
                    RewriteDriver* driver,
                    CacheableResourceBase* resource)
      : AsyncFetchWithLock(server_context->lock_hasher(),
                           request_context,
                           url,
                           cache_key,
                           server_context->lock_manager(),
                           handler),
        resource_(resource),
        server_context_(server_context),
        driver_(driver),
        rewrite_options_(rewrite_options),
        message_handler_(handler),
        no_cache_ok_(false),
        fetcher_(NULL),
        fallback_fetch_(NULL) {
    if (fallback_value != NULL) {
      fallback_value_.Link(fallback_value);
    }
  }

  virtual ~FetchCallbackBase() {}

  // Set this to true if implementing a kLoadEvenIfNotCacheable policy.
  void set_no_cache_ok(bool x) { no_cache_ok_ = x; }

 protected:
  // The two derived classes differ in how they provide the
  // fields below. LoadAndCallback updates the resource directly, while
  // Freshen does not actually change the resource object.
  virtual HTTPValue* http_value() = 0;
  virtual HTTPCache* http_cache() = 0;
  virtual HTTPValueWriter* http_value_writer() = 0;

  // Subclasses will also want to override AsyncFetchWithLock's Finalize
  // to get all the cases.

  // Overridden from AsyncFetch.
  virtual void HandleDone(bool success) {
    bool cached = false;
    // Do not store the response in cache if we are using the fallback.
    if (fallback_fetch_ != NULL && fallback_fetch_->serving_fallback()) {
      // Normally AddToCache would classify the failure, but we don't
      // use that in case of fallback, so make sure to compute it here.
      // Unfortunately, FallbackSharedAsyncFetch has already got
      // rid of the actual headers of the physical reply, but luckily it only
      // ever does things on 5xx anyway.
      // (See FallbackSharedAsyncFetch::HandleHeadersComplete())
      resource_->set_fetch_response_status(kFetchStatusOtherError);
      success = true;
    } else {
      cached = AddToCache(success && http_value_writer()->has_buffered());
      // Unless the client code explicitly opted into dealing with potentially
      // uncacheable content (by passing in kLoadEvenIfNotCacheable to
      // LoadAsync) we turn it into a fetch failure so we do not
      // end up inadvertently rewriting something that's private or highly
      // volatile.
      if ((!cached && !no_cache_ok_) || !http_value_writer()->has_buffered()) {
        success = false;
      }
    }
    if (http_value()->Empty()) {
      // If there have been no writes so far, write an empty string to the
      // HTTPValue. Note that this is required since empty writes aren't
      // propagated while fetching and we need to write something to the
      // HTTPValue so that we can successfully extract empty content from it.
      http_value()->Write("", message_handler_);
    }

    // This will also invoke Finalize() on the subclasses.
    AsyncFetchWithLock::HandleDone(success);
  }

  // Overridden from AsyncFetch.
  virtual void HandleHeadersComplete() {
    if (fallback_fetch_ != NULL && fallback_fetch_->serving_fallback()) {
      response_headers()->ComputeCaching();
    }
    http_value_writer()->CheckCanCacheElseClear(response_headers());
    AsyncFetchWithLock::HandleHeadersComplete();
  }

  // Overridden from AsyncFetch.
  virtual bool HandleWrite(const StringPiece& content,
                           MessageHandler* handler) {
    bool success = http_value_writer()->Write(content, handler);
    return success && AsyncFetchWithLock::HandleWrite(content, handler);
  }

  // Overridden from AsyncFetchWithLock.
  virtual void StartFetch(UrlAsyncFetcher* fetcher, MessageHandler* handler) {
    fetch_url_ = url();
    fetcher_ = fetcher;
    if (!request_headers()->Has(HttpAttributes::kReferer)) {
      if (IsBackgroundFetch()) {
        // Set referer for background fetching, if the referer is missing.
        request_headers()->Add(HttpAttributes::kReferer,
                               driver_->base_url().Spec());
      } else if (driver_->request_headers() != NULL) {
        const char* referer_str = driver_->request_headers()->Lookup1(
            HttpAttributes::kReferer);
        if (referer_str != NULL) {
          request_headers()->Add(HttpAttributes::kReferer, referer_str);
        }
      }
    }

    server_context_->rewrite_options_manager()->PrepareRequest(
        rewrite_options_,
        request_context(),
        &fetch_url_,
        request_headers(),
        NewCallback(this, &FetchCallbackBase::PrepareRequestDone));
  }

  void PrepareRequestDone(bool success) {
    if (!success) {
      // TODO(gee): Will this hang the state machine?
      return;
    }

    AsyncFetch* fetch = this;
    if (rewrite_options_->serve_stale_if_fetch_error() &&
        !fallback_value_.Empty()) {
      // Use a stale value if the fetch from the backend fails.
      fallback_fetch_ = new FallbackSharedAsyncFetch(
          this, &fallback_value_, message_handler_);
      fallback_fetch_->set_fallback_responses_served(
          server_context_->rewrite_stats()->fallback_responses_served());
      fetch = fallback_fetch_;
    }
    if (!fallback_value_.Empty()) {
      // Use the conditional headers in a stale response in cache while
      // triggering the outgoing fetch.
      ConditionalSharedAsyncFetch* conditional_fetch =
          new ConditionalSharedAsyncFetch(
              fetch, &fallback_value_, message_handler_);
      conditional_fetch->set_num_conditional_refreshes(
          server_context_->rewrite_stats()->num_conditional_refreshes());
      fetch = conditional_fetch;
    }
    resource_->PrepareRequest(fetch->request_context(),
                              fetch->request_headers());
    fetcher_->Fetch(fetch_url_, message_handler_, fetch);
  }

 private:
  // Returns true if the result was successfully cached.
  bool AddToCache(bool success) {
    ResponseHeaders* headers = response_headers();
    HTTPValue* value = http_value();

    // Merge in any extra response headers.
    headers->UpdateFrom(*extra_response_headers());
    resource_->PrepareResponseHeaders(headers);
    headers->ComputeCaching();
    headers->FixDateHeaders(http_cache()->timer()->NowMs());
    if (rewrite_options_->IsCacheTtlOverridden(url())) {
      headers->ForceCaching(rewrite_options_->override_caching_ttl_ms());
    }
    bool cacheable = resource_->IsValidAndCacheableImpl(*headers);
    StringPiece contents;
    if (!value->ExtractContents(&contents)) {
      contents.clear();
    }
    FetchResponseStatus fetch_status = HttpCacheFailure::ClassifyFailure(
        *headers, contents, success, cacheable);
    resource_->set_fetch_response_status(fetch_status);
    if (fetch_status == kFetchStatusOK) {
      value->SetHeaders(headers);
      // Note that we could potentially store Vary:Cookie responses
      // here, as we will have fetched the resource without cookies.
      // But we must be careful in the mod_pagespeed ipro flow,
      // where we must avoid storing any resource obtained with a
      // Cookie.  For now we don't implement this.
      http_cache()->Put(resource_->cache_key(), driver_->CacheFragment(),
                        RequestHeaders::Properties(),
                        request_context()->options(),
                        value, message_handler_);
      return true;
    } else {
      http_cache()->RememberFailure(resource_->cache_key(),
                                    driver_->CacheFragment(),
                                    fetch_status,
                                    message_handler_);
      return false;
    }
  }

  CacheableResourceBase* resource_;  // owned by the callback.
  ServerContext* server_context_;
  RewriteDriver* driver_;
  const RewriteOptions* rewrite_options_;
  MessageHandler* message_handler_;

  // TODO(jmarantz): consider request_headers.  E.g. will we ever
  // get different resources depending on user-agent?
  HTTPValue fallback_value_;

  // If this is true, loading of non-cacheable resources will succeed.
  // Used to implement kLoadEvenIfNotCacheable.
  bool no_cache_ok_;

  // These 2 are set only once we get to StartFetch
  UrlAsyncFetcher* fetcher_;
  GoogleString fetch_url_;

  FallbackSharedAsyncFetch* fallback_fetch_;

  DISALLOW_COPY_AND_ASSIGN(FetchCallbackBase);
};

// Writes result into cache. Use this when you do not need to wait for the
// response, you just want it to be asynchronously placed in the HttpCache.
//
// For example, this is used for fetches and refreshes of resources
// discovered while rewriting HTML. Note that this uses the Last-Modified and
// If-None-Match headers of the stale value in cache to conditionally refresh
// the resource.
class CacheableResourceBase::FreshenFetchCallback : public FetchCallbackBase {
 public:
  FreshenFetchCallback(const GoogleString& url,
                       const GoogleString& cache_key,
                       HTTPCache* http_cache,
                       ServerContext* server_context,
                       RewriteDriver* rewrite_driver,
                       const RewriteOptions* rewrite_options,
                       HTTPValue* fallback_value,
                       CacheableResourceBase* resource,
                       Resource::FreshenCallback* callback)
      : FetchCallbackBase(server_context,
                          rewrite_options,
                          url,
                          cache_key,
                          fallback_value,
                          rewrite_driver->request_context(),
                          server_context->message_handler(),
                          rewrite_driver,
                          resource),
        url_(url),
        http_cache_(http_cache),
        rewrite_driver_(rewrite_driver),
        callback_(callback),
        http_value_writer_(&http_value_, http_cache_),
        resource_(resource),
        own_resource_(resource) {
    // TODO(morlovich): This is duplicated a few times, clean this up.
    response_headers()->set_implicit_cache_ttl_ms(
        rewrite_options->implicit_cache_ttl_ms());
    response_headers()->set_min_cache_ttl_ms(
        rewrite_options->min_cache_ttl_ms());
  }

  virtual void Finalize(bool lock_failure, bool resource_ok) {
    if (callback_ != NULL) {
      if (!lock_failure) {
        resource_ok &= resource_->UpdateInputInfoForFreshen(
            *response_headers(), http_value_, callback_);
      }
      callback_->Done(lock_failure, resource_ok);
    }
    rewrite_driver_->DecrementAsyncEventsCount();
    // AsyncFetchWithLock::HandleDone (which calls this method)
    // will take care of deleting 'this'.
  }

  virtual HTTPValue* http_value() { return &http_value_; }
  virtual HTTPCache* http_cache() { return http_cache_; }
  virtual HTTPValueWriter* http_value_writer() { return &http_value_writer_; }
  virtual bool ShouldYieldToRedundantFetchInProgress() { return true; }
  virtual bool IsBackgroundFetch() const { return true; }

 private:
  GoogleString url_;
  HTTPCache* http_cache_;
  RewriteDriver* rewrite_driver_;
  Resource::FreshenCallback* callback_;
  HTTPValue http_value_;
  HTTPValueWriter http_value_writer_;
  CacheableResourceBase* resource_;
  ResourcePtr own_resource_;  // keep alive resource since callback may be NULL

  DISALLOW_COPY_AND_ASSIGN(FreshenFetchCallback);
};

// Fetch callback that writes result directly into a resource.
class CacheableResourceBase::LoadFetchCallback
    : public FetchCallbackBase {
 public:
  explicit LoadFetchCallback(Resource::AsyncCallback* callback,
                             CacheableResourceBase* resource,
                             const RequestContextPtr& request_context)
      : FetchCallbackBase(resource->server_context(),
                          resource->rewrite_options(),
                          resource->url(),
                          resource->cache_key(),
                          &resource->fallback_value_,
                          request_context,
                          resource->server_context()->message_handler(),
                          resource->rewrite_driver(),
                          resource),
        resource_(resource),
        callback_(callback),
        http_value_writer_(http_value(), http_cache()),
        respect_vary_(resource->respect_vary()) {
    set_response_headers(&resource_->response_headers_);
    response_headers()->set_implicit_cache_ttl_ms(
        resource->rewrite_options()->implicit_cache_ttl_ms());
    response_headers()->set_min_cache_ttl_ms(
        resource->rewrite_options()->min_cache_ttl_ms());
  }

  virtual void Finalize(bool lock_failure, bool resource_ok) {
    if (!lock_failure && resource_ok) {
      // Because we've authorized the Fetcher to directly populate the
      // ResponseHeaders in resource_->response_headers_, we must explicitly
      // propagate the content-type to the resource_->type_.
      resource_->DetermineContentType();
    } else {
      DCHECK_NE(kFetchStatusNotSet,  resource_->fetch_response_status());
      // It's possible that the fetcher has read some of the headers into
      // our response_headers (perhaps even a 200) before it called Done(false)
      // or before we decided inside AddToCache() that we don't want to deal
      // with this particular resource. In that case, make sure to clear the
      // response_headers() so the various validity bits in Resource are
      // accurate.
      response_headers()->Clear();
    }

    Statistics* stats = resource_->server_context()->statistics();
    if (resource_ok) {
      stats->GetVariable(RewriteStats::kNumResourceFetchSuccesses)->Add(1);
    } else {
      stats->GetVariable(RewriteStats::kNumResourceFetchFailures)->Add(1);
    }
    callback_->Done(lock_failure, resource_ok);
    // AsyncFetchWithLock will delete 'this' eventually.
  }

  virtual bool IsBackgroundFetch() const {
    return resource_->is_background_fetch();
  }

  virtual HTTPValue* http_value() { return &resource_->value_; }
  virtual HTTPCache* http_cache() {
    return resource_->server_context()->http_cache();
  }
  virtual HTTPValueWriter* http_value_writer() { return &http_value_writer_; }
  virtual bool ShouldYieldToRedundantFetchInProgress() { return false; }

 private:
  CacheableResourceBase* resource_;
  Resource::AsyncCallback* callback_;
  HTTPValueWriter http_value_writer_;
  ResponseHeaders::VaryOption respect_vary_;

  DISALLOW_COPY_AND_ASSIGN(LoadFetchCallback);
};

class CacheableResourceBase::LoadHttpCacheCallback
    : public OptionsAwareHTTPCacheCallback {
 public:
  LoadHttpCacheCallback(
      const RequestContextPtr& request_context,
      NotCacheablePolicy not_cacheable_policy,
      AsyncCallback* resource_callback,
      CacheableResourceBase* resource);
  virtual ~LoadHttpCacheCallback();
  virtual void Done(HTTPCache::FindResult find_result);

 private:
  void LoadAndSaveToCache();

  // protected via resource_callback_->resource().
  CacheableResourceBase* resource_;
  Resource::AsyncCallback* resource_callback_;
  Resource::NotCacheablePolicy not_cacheable_policy_;
  DISALLOW_COPY_AND_ASSIGN(LoadHttpCacheCallback);
};

CacheableResourceBase::LoadHttpCacheCallback::LoadHttpCacheCallback(
    const RequestContextPtr& request_context,
    NotCacheablePolicy not_cacheable_policy,
    AsyncCallback* resource_callback,
    CacheableResourceBase* resource)
    : OptionsAwareHTTPCacheCallback(
          resource->rewrite_options(), request_context),
      resource_(resource),
      resource_callback_(resource_callback),
      not_cacheable_policy_(not_cacheable_policy) {
}

CacheableResourceBase::LoadHttpCacheCallback::~LoadHttpCacheCallback() {
}

void CacheableResourceBase::LoadHttpCacheCallback::Done(
    HTTPCache::FindResult find_result) {
  MessageHandler* handler = resource_->message_handler();

  // Note, we pass lock_failure==false to the resource callbacks
  // when we are taking action based on the cache.  We haven't locked,
  // but we didn't fail-to-lock.  Resource callbacks need to know if
  // the lock failed, because they will delete expired cache metadata
  // if they have the lock, or if the lock was not needed, but they
  // should not delete it if they fail to lock.
  switch (find_result.status) {
    case HTTPCache::kFound:
      resource_->hits_->Add(1);
      resource_->Link(http_value(), handler);
      resource_->response_headers()->CopyFrom(*response_headers());
      resource_->DetermineContentType();
      resource_->RefreshIfImminentlyExpiring();
      resource_->set_fetch_response_status(
          response_headers()->status_code() == HttpStatus::kOK ?
              kFetchStatusOK : kFetchStatusOtherError);
      resource_callback_->Done(false /* lock_failure */,
                               true /* resource_ok */);
      break;
    case HTTPCache::kRecentFailure:
      // We may need to retry even if we have a cached failure if:
      // a) The user wants uncacheable resources, and that's the failure we
      //    recorded.
      // b) The fetch is user-facing and the "failure" is actually us
      //    load-shedding in the past.
      if ((not_cacheable_policy_ == Resource::kLoadEvenIfNotCacheable &&
           (find_result.failure_details == kFetchStatusUncacheable200 ||
            find_result.failure_details == kFetchStatusUncacheableError ||
            find_result.failure_details == kFetchStatusEmpty)) ||
          (!resource_->is_background_fetch() &&
            find_result.failure_details == kFetchStatusDropped)) {
        resource_->recent_uncacheables_miss_->Add(1);
        LoadAndSaveToCache();
      } else {
        if (find_result.failure_details == kFetchStatusUncacheable200 ||
            find_result.failure_details == kFetchStatusUncacheableError) {
          resource_->recent_uncacheables_failure_->Add(1);
        } else {
          resource_->recent_fetch_failures_->Add(1);
        }
        resource_->set_fetch_response_status(find_result.failure_details);
        resource_callback_->Done(false /* lock_failure */,
                                 false /* resource_ok */);
      }
      break;
    case HTTPCache::kNotFound:
      resource_->misses_->Add(1);
      // If not, load it asynchronously.
      // Link the fallback value which can be used if the fetch fails.
      resource_->LinkFallbackValue(fallback_http_value());
      LoadAndSaveToCache();
      break;
  }
  delete this;
}

void CacheableResourceBase::LoadHttpCacheCallback::LoadAndSaveToCache() {
  if (resource_->ShouldSkipBackgroundFetch()) {
    // Note that this isn't really a lock failure, but we treat them the same
    // way.
    resource_callback_->Done(true /* lock_failure */,
                             false /* resource_ok */);
    return;
  }
  CHECK(resource_callback_ != NULL)
      << "A callback must be supplied, or else it will "
          "not be possible to determine when it's safe to delete the resource.";
  CHECK(resource_ == resource_callback_->resource().get())
      << "The callback must keep a reference to the resource";
  DCHECK(!resource_->loaded()) << "Shouldn't get this far if already loaded.";
  LoadFetchCallback* cb =
      new LoadFetchCallback(resource_callback_, resource_, request_context());
  if (not_cacheable_policy_ == Resource::kLoadEvenIfNotCacheable) {
    cb->set_no_cache_ok(true);
  }
  cb->Start(resource_->rewrite_driver()->async_fetcher());
}

// HTTPCache::Callback which checks if we have a fresh response in the cache.
// Note that we don't really care about what the response in cache is. We just
// check whether it is fresh enough to avoid having to trigger an external
// fetch. This keeps the RewriteDriver alive via the async event count.
class CacheableResourceBase::FreshenHttpCacheCallback
    : public OptionsAwareHTTPCacheCallback {
 public:
  FreshenHttpCacheCallback(const GoogleString& url,
                           const GoogleString& cache_key,
                           ServerContext* server_context,
                           RewriteDriver* driver,
                           const RewriteOptions* options,
                           CacheableResourceBase* resource,
                           Resource::FreshenCallback* callback)
      : OptionsAwareHTTPCacheCallback(options, driver->request_context()),
        url_(url),
        cache_key_(cache_key),
        server_context_(server_context),
        driver_(driver),
        options_(options),
        resource_(resource),
        own_resource_(resource),
        callback_(callback) {}

  virtual ~FreshenHttpCacheCallback() {}

  virtual void Done(HTTPCache::FindResult find_result) {
    if (find_result.status == HTTPCache::kNotFound &&
        !resource_->ShouldSkipBackgroundFetch()) {
      // Not found in cache. Invoke the fetcher.
      FreshenFetchCallback* cb = new FreshenFetchCallback(
          url_, cache_key_, server_context_->http_cache(), server_context_,
          driver_, options_, fallback_http_value(), resource_, callback_);
      cb->Start(driver_->async_fetcher());
    } else {
      if (callback_ != NULL) {
        bool success = (find_result.status == HTTPCache::kFound) &&
                       resource_->UpdateInputInfoForFreshen(
                           *response_headers(), *http_value(), callback_);
        callback_->Done(true, success);
      }
      driver_->DecrementAsyncEventsCount();
    }
    delete this;
  }

  // Checks if the response is fresh enough. We may have an imminently
  // expiring resource in the L1 cache, but a fresh response in the L2 cache and
  // regular cache lookups will return the response in the L1.
  virtual bool IsFresh(const ResponseHeaders& headers) {
    int64 date_ms = headers.date_ms();
    int64 expiry_ms = headers.CacheExpirationTimeMs();
    return !ResponseHeaders::IsImminentlyExpiring(
        date_ms, expiry_ms, server_context_->timer()->NowMs(),
        options_->ComputeHttpOptions());
  }

 private:
  GoogleString url_;
  GoogleString cache_key_;
  ServerContext* server_context_;
  RewriteDriver* driver_;
  const RewriteOptions* options_;
  CacheableResourceBase* resource_;
  // Note that we need to own the resource since callback_ might be NULL.
  ResourcePtr own_resource_;
  Resource::FreshenCallback* callback_;
  DISALLOW_COPY_AND_ASSIGN(FreshenHttpCacheCallback);
};

CacheableResourceBase::CacheableResourceBase(
    StringPiece stat_prefix,
    StringPiece url,
    StringPiece cache_key,
    const ContentType* type,
    RewriteDriver* rewrite_driver)
    : Resource(rewrite_driver, type),
      url_(url.data(), url.size()),
      cache_key_(cache_key.data(), cache_key.size()),
      rewrite_driver_(rewrite_driver) {
  set_enable_cache_purge(rewrite_options()->enable_cache_purge());
  set_respect_vary(ResponseHeaders::GetVaryOption(
      rewrite_options()->respect_vary()));
  set_proactive_resource_freshening(
      rewrite_options()->proactive_resource_freshening());

  Statistics* stats = server_context()->statistics();
  hits_ = stats->GetVariable(StrCat(stat_prefix, kHitSuffix));
  recent_fetch_failures_ =
      stats->GetVariable(StrCat(stat_prefix, kRecentFetchFailureSuffix));
  recent_uncacheables_miss_ =
      stats->GetVariable(StrCat(stat_prefix, kRecentUncacheableMiss));
  recent_uncacheables_failure_ =
      stats->GetVariable(StrCat(stat_prefix, kRecentUncacheableFailure));
  misses_ = stats->GetVariable(StrCat(stat_prefix, kMissSuffix));
}

CacheableResourceBase::~CacheableResourceBase() {
}

bool CacheableResourceBase::IsValidAndCacheable() const {
  return IsValidAndCacheableImpl(*response_headers());
}

bool CacheableResourceBase::IsValidAndCacheableImpl(
    const ResponseHeaders& headers) const {
  if (headers.status_code() != HttpStatus::kOK) {
    return false;
  }

  // Conservatively assume that the request has cookies, since the site may
  // want to serve different content based on the cookie. If we consider the
  // response to be cacheable here, we will serve the optimized version
  // without contacting the origin which would be against the webmaster's
  // intent. We also don't have cookies available at lookup time, so we
  // cannot try to use this response only when the request doesn't have a
  // cookie.
  RequestHeaders::Properties req_properties;
  bool cacheable = headers.IsProxyCacheable(req_properties, respect_vary(),
                                            ResponseHeaders::kNoValidator);

  // If we are setting a TTL for HTML, we cannot rewrite any resource
  // with a shorter TTL.
  cacheable &= (headers.cache_ttl_ms() >=
                rewrite_options()->min_resource_cache_time_to_rewrite_ms());

  if (!cacheable && !http_cache()->force_caching()) {
    return false;
  }

  return !http_cache()->IsExpired(headers);
}

void CacheableResourceBase::InitStats(StringPiece stat_prefix,
                                      Statistics* stats) {
  stats->AddVariable(StrCat(stat_prefix, kHitSuffix));
  stats->AddVariable(StrCat(stat_prefix, kRecentFetchFailureSuffix));
  stats->AddVariable(StrCat(stat_prefix, kRecentUncacheableMiss));
  stats->AddVariable(StrCat(stat_prefix, kRecentUncacheableFailure));
  stats->AddVariable(StrCat(stat_prefix, kMissSuffix));
}

void CacheableResourceBase::RefreshIfImminentlyExpiring() {
  if (!http_cache()->force_caching()) {
    const ResponseHeaders* headers = response_headers();
    int64 start_date_ms = headers->date_ms();
    int64 expire_ms = headers->CacheExpirationTimeMs();
    if (ResponseHeaders::IsImminentlyExpiring(
            start_date_ms, expire_ms, timer()->NowMs(),
            rewrite_options()->ComputeHttpOptions())) {
      Freshen(NULL, server_context()->message_handler());
    }
  }
}

void CacheableResourceBase::LoadAndCallback(
    NotCacheablePolicy not_cacheable_policy,
    const RequestContextPtr& request_context,
    AsyncCallback* callback) {
  LoadHttpCacheCallback* cache_callback =
      new LoadHttpCacheCallback(request_context, not_cacheable_policy,
                                callback, this);

  cache_callback->set_is_background(is_background_fetch());
  http_cache()->Find(cache_key(), rewrite_driver()->CacheFragment(),
                     message_handler(), cache_callback);
}

void CacheableResourceBase::Freshen(Resource::FreshenCallback* callback,
                                    MessageHandler* handler) {
  // TODO(jmarantz): use if-modified-since
  // For now this is much like Load(), except we do not
  // touch our value, but just the cache
  HTTPCache* http_cache = server_context()->http_cache();
  // Ensure that the rewrite driver is alive until the freshen is completed.
  rewrite_driver_->IncrementAsyncEventsCount();

  FreshenHttpCacheCallback* freshen_callback = new FreshenHttpCacheCallback(
      url(), cache_key(), server_context(), rewrite_driver_, rewrite_options(),
      this, callback);
  // Lookup the cache before doing the fetch since the response may have already
  // been fetched elsewhere.
  http_cache->Find(cache_key(), rewrite_driver()->CacheFragment(),
                   handler, freshen_callback);
}

bool CacheableResourceBase::UpdateInputInfoForFreshen(
    const ResponseHeaders& headers,
    const HTTPValue& value,
    Resource::FreshenCallback* callback) {
  InputInfo* input_info = callback->input_info();
  if (input_info != NULL && input_info->has_input_content_hash() &&
      IsValidAndCacheableImpl(headers)) {
    StringPiece content;
    if (value.ExtractContents(&content)) {
      GoogleString new_hash =
          server_context()->contents_hasher()->Hash(content);
      // TODO(nikhilmadan): Consider using the Etag / Last-Modified header to
      // validate if the resource has changed instead of computing the hash.
      if (new_hash == input_info->input_content_hash()) {
        FillInPartitionInputInfoFromResponseHeaders(headers, input_info);
        return true;
      }
    }
  }
  return false;
}

const RewriteOptions* CacheableResourceBase::rewrite_options() const {
  return rewrite_driver_->options();
}

void CacheableResourceBase::PrepareRequest(
    const RequestContextPtr& request_context, RequestHeaders* headers) {
}

void CacheableResourceBase::PrepareResponseHeaders(ResponseHeaders* headers) {
}

bool CacheableResourceBase::ShouldSkipBackgroundFetch() const {
  return is_background_fetch() &&
      rewrite_options()->disable_background_fetches_for_bots() &&
      rewrite_driver()->request_properties()->IsBot();
}

}  // namespace net_instaweb