/*
 * Copyright 2013 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: morlovich@google.com (Maksim Orlovich)

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

#include "net/instaweb/http/public/counting_url_async_fetcher.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/mock_url_fetcher.h"
#include "net/instaweb/http/public/request_context.h"
#include "net/instaweb/rewriter/cached_result.pb.h"
#include "net/instaweb/rewriter/public/mock_resource_callback.h"
#include "net/instaweb/rewriter/public/resource.h"  // for Resource, etc
#include "net/instaweb/rewriter/public/rewrite_driver.h"
#include "net/instaweb/rewriter/public/rewrite_test_base.h"
#include "pagespeed/kernel/base/gtest.h"
#include "pagespeed/kernel/base/mock_message_handler.h"
#include "pagespeed/kernel/base/ref_counted_ptr.h"
#include "pagespeed/kernel/base/statistics.h"
#include "pagespeed/kernel/base/string.h"  // for GoogleString
#include "pagespeed/kernel/base/timer.h"
#include "pagespeed/kernel/cache/lru_cache.h"
#include "pagespeed/kernel/http/content_type.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 kTestUrl[] = "http://www.example.com/";
const char kTestRef[] = "http://www.example.com/some_page";
const char kContent[] = "content!";

class TestResource : public CacheableResourceBase {
 public:
  explicit TestResource(RewriteDriver* rewrite_driver)
      : CacheableResourceBase("test", kTestUrl, kTestUrl, NULL, rewrite_driver),
        cache_key_(kTestUrl),
        do_prepare_request_(false),
        do_prepare_response_(false) {
  }

  static void InitStats(Statistics* stats) {
    CacheableResourceBase::InitStats("test", stats);
  }

  virtual GoogleString cache_key() const { return cache_key_; }
  void set_cache_key(StringPiece ck) {
    ck.CopyToString(&cache_key_);
  }

  virtual void PrepareRequest(const RequestContextPtr& request_context,
                              RequestHeaders* headers) {
    if (do_prepare_request_) {
      // To test that this gets invoked properly, we set the referer header
      // since MockUrlFetcher records those.
      headers->Replace(HttpAttributes::kReferer, kTestRef);
      request_context->AddSessionAuthorizedFetchOrigin(kTestUrl);
    }
  }

  virtual void PrepareResponseHeaders(ResponseHeaders* headers) {
    if (do_prepare_response_) {
      headers->Remove(HttpAttributes::kCacheControl, "private");
    }
  }

  void set_do_prepare_request(bool x) {
    do_prepare_request_ = x;
  }

  void set_do_prepare_response(bool x) {
    do_prepare_response_ = x;
  }

  // Wipe any loaded values, but not the configuration.
  void Reset() {
    HTTPValue empty_value;
    // Don't want it to totally empty, or it won't get set.
    empty_value.Write("", server_context()->message_handler());
    Link(&empty_value, server_context()->message_handler());
    LinkFallbackValue(&empty_value);
  }

 protected:
  GoogleString cache_key_;
  bool do_prepare_request_;
  bool do_prepare_response_;
};

class MockFreshenCallback : public Resource::FreshenCallback {
 public:
  MockFreshenCallback(const ResourcePtr& resource,
                      InputInfo* input_info)
      : FreshenCallback(resource),
        input_info_(input_info),
        done_(false),
        extend_success_(false) {
  }

  virtual InputInfo* input_info() { return input_info_; }

  virtual void Done(bool lock_failure, bool extend_success) {
    done_ = true;
    extend_success_ = extend_success;
  }

  bool done() const { return done_; }
  bool extend_success() const { return extend_success_; }

 private:
  InputInfo* input_info_;
  bool done_;
  bool extend_success_;
};

}  // namespace

class CacheableResourceBaseTest : public RewriteTestBase {
 protected:
  virtual void SetUp() {
    RewriteTestBase::SetUp();
    TestResource::InitStats(server_context()->statistics());

    resource_.reset(new TestResource(rewrite_driver()));
  }

  void CheckStats(TestResource* resource,
                  int expect_hits,
                  int expect_recent_fetch_failures,
                  int expect_recent_uncacheables_miss,
                  int expect_recent_uncacheables_failure,
                  int expect_misses) {
    EXPECT_EQ(expect_hits,
              resource->hits_->Get());
    EXPECT_EQ(expect_recent_fetch_failures,
              resource->recent_fetch_failures_->Get());
    EXPECT_EQ(expect_recent_uncacheables_miss,
              resource->recent_uncacheables_miss_->Get());
    EXPECT_EQ(expect_recent_uncacheables_failure,
              resource->recent_uncacheables_failure_->Get());
    EXPECT_EQ(expect_misses,
              resource->misses_->Get());
  }

  RefCountedPtr<TestResource> resource_;
};

TEST_F(CacheableResourceBaseTest, BasicCached) {
  SetResponseWithDefaultHeaders(kTestUrl, kContentTypeText,
                                kContent, 1000);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());
  EXPECT_EQ(kContent, resource_->ExtractUncompressedContents());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 0, 0, 0, 1);

  // 2nd read should be cached.
  resource_->Reset();
  MockResourceCallback callback2(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback2);
  EXPECT_TRUE(callback2.done());
  EXPECT_TRUE(callback2.success());
  EXPECT_EQ(kContent, resource_->ExtractUncompressedContents());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 1, 0, 0, 0, 1);

  // Make sure freshening happens. The rest resource is set to 1000 sec ttl,
  // so forward time 900 seconds ahead.
  AdvanceTimeMs(900 * Timer::kSecondMs);
  resource_->Reset();
  MockResourceCallback callback3(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback3);
  EXPECT_TRUE(callback3.done());
  EXPECT_TRUE(callback3.success());
  EXPECT_EQ(kContent, resource_->ExtractUncompressedContents());
  // Freshening resulted in an extra fetch
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 2, 0, 0, 0, 1);
}

TEST_F(CacheableResourceBaseTest, Fallback) {
  options()->set_serve_stale_if_fetch_error(true);
  mock_url_fetcher()->Disable();
  mock_url_fetcher()->set_error_message("oww!");

  ResponseHeaders ok_response_headers;
  SetDefaultLongCacheHeaders(&kContentTypeText, &ok_response_headers);

  HTTPValue fallback;
  fallback.SetHeaders(&ok_response_headers);
  EXPECT_TRUE(fallback.Write("fallback", server_context()->message_handler()));
  EXPECT_TRUE(fallback.Flush(server_context()->message_handler()));
  resource_->LinkFallbackValue(&fallback);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());
  EXPECT_STREQ("fallback", resource_->ExtractUncompressedContents());
  EXPECT_EQ(kFetchStatusOtherError, resource_->fetch_response_status());
}

TEST_F(CacheableResourceBaseTest, FallbackEmpty) {
  // Regression test. This used to CHECK-fail in some intermediate revisions.
  options()->set_serve_stale_if_fetch_error(true);
  mock_url_fetcher()->Disable();
  mock_url_fetcher()->set_error_message("oww!");

  ResponseHeaders ok_response_headers;
  SetDefaultLongCacheHeaders(&kContentTypeText, &ok_response_headers);

  HTTPValue fallback;
  fallback.SetHeaders(&ok_response_headers);
  EXPECT_TRUE(fallback.Write("", server_context()->message_handler()));
  EXPECT_TRUE(fallback.Flush(server_context()->message_handler()));
  resource_->LinkFallbackValue(&fallback);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());
  EXPECT_STREQ("", resource_->ExtractUncompressedContents());
  EXPECT_EQ(kFetchStatusOtherError, resource_->fetch_response_status());
}

TEST_F(CacheableResourceBaseTest, Private) {
  ResponseHeaders response_headers;
  SetDefaultLongCacheHeaders(&kContentTypeText, &response_headers);
  response_headers.Add(HttpAttributes::kCacheControl, "private");
  SetFetchResponse(kTestUrl, response_headers, kContent);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());

  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_FALSE(callback.success());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 0, 0, 0, 1);

  // The non-cacheability should be cached.
  resource_->Reset();
  MockResourceCallback callback2(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback2);
  EXPECT_TRUE(callback2.done());
  EXPECT_FALSE(callback2.success());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 0, 0, 1, 1);
}

TEST_F(CacheableResourceBaseTest, PrivateForFetch) {
  // This test private + kLoadEvenIfNotCacheable.
  ResponseHeaders response_headers;
  SetDefaultLongCacheHeaders(&kContentTypeText, &response_headers);
  response_headers.Add(HttpAttributes::kCacheControl, "private");
  SetFetchResponse(kTestUrl, response_headers, kContent);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());

  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());
  EXPECT_EQ(kContent, resource_->ExtractUncompressedContents());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 0, 0, 0, 1);

  // Since it's non-cacheable, but we have kLoadEvenIfNotCacheable
  // set, we should re-fetch it.
  resource_->Reset();
  MockResourceCallback callback2(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback2);
  EXPECT_TRUE(callback2.done());
  EXPECT_TRUE(callback2.success());
  EXPECT_EQ(kContent, resource_->ExtractUncompressedContents());
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 0, 1, 0, 1);
}

TEST_F(CacheableResourceBaseTest, FetchFailure) {
  SetFetchFailOnUnexpected(false);
  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());

  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_FALSE(callback.success());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 0, 0, 0, 1);

  // Failure should get cached, and we should take advantage of it.
  resource_->Reset();
  MockResourceCallback callback2(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback2);
  EXPECT_TRUE(callback2.done());
  EXPECT_FALSE(callback2.success());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 1, 0, 0, 1);

  // Now advance time, should force a refetch.
  int64 remember_sec = server_context()->http_cache()->failure_caching_ttl_sec(
                           kFetchStatusOtherError);
  AdvanceTimeMs(2 * remember_sec * Timer::kSecondMs);
  resource_->Reset();
  MockResourceCallback callback3(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback3);
  EXPECT_TRUE(callback3.done());
  EXPECT_FALSE(callback3.success());
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());
  CheckStats(resource_.get(), 0, 1, 0, 0, 2);
}

TEST_F(CacheableResourceBaseTest, DropHandling) {
  // First have mock fetcher emulate a drop.
  ResponseHeaders not_found;
  SetDefaultLongCacheHeaders(&kContentTypeHtml, &not_found);
  not_found.SetStatusAndReason(HttpStatus::kUnavailable);
  not_found.Add(HttpAttributes::kXPsaLoadShed, "1");
  SetFetchResponse("http://www.example.com/", not_found, "hmm");

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());

  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_FALSE(resource_->IsValidAndCacheable());

  resource_->Reset();

  // Now have the fetch result in a 200.
  ResponseHeaders found;
  SetDefaultLongCacheHeaders(&kContentTypeCss, &found);
  found.SetStatusAndReason(HttpStatus::kOK);
  SetFetchResponse("http://www.example.com/", found, "* {display: stylish; }");

  // Still cached since background fetch.
  MockResourceCallback callback2(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());

  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback2);
  EXPECT_TRUE(callback2.done());
  EXPECT_FALSE(resource_->IsValidAndCacheable());
  resource_->Reset();

  // Marked as a non-background, will retry.
  resource_->set_is_background_fetch(false);
  MockResourceCallback callback3(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());

  resource_->LoadAsync(Resource::kLoadEvenIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback3);
  EXPECT_TRUE(callback3.done());
  EXPECT_TRUE(resource_->IsValidAndCacheable());
}

TEST_F(CacheableResourceBaseTest, FreshenInfo) {
  SetResponseWithDefaultHeaders(kTestUrl, kContentTypeText,
                                kContent, 1000);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());

  InputInfo input_info;
  resource_->FillInPartitionInputInfo(Resource::kIncludeInputHash,
                                      &input_info);
  InputInfo input_info2 = input_info;

  // Move time ahead so freshening actually does something.
  AdvanceTimeMs(900 * Timer::kSecondMs);

  MockFreshenCallback freshen_cb(ResourcePtr(resource_.get()), &input_info);
  resource_->Freshen(&freshen_cb, message_handler());
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());

  EXPECT_TRUE(freshen_cb.done());
  EXPECT_TRUE(freshen_cb.extend_success());

  // Expiration time must have moved ahead, too.
  EXPECT_EQ(1000 * Timer::kSecondMs + timer()->NowMs(),
            input_info.expiration_time_ms());

  // The above freshened from fetches, now we should be able to do it
  // from cache as well.
  MockFreshenCallback freshen_cb2(ResourcePtr(resource_.get()), &input_info2);
  resource_->Freshen(&freshen_cb2, message_handler());
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());
  EXPECT_TRUE(freshen_cb.done());
  EXPECT_TRUE(freshen_cb.extend_success());
  EXPECT_EQ(1000 * Timer::kSecondMs + timer()->NowMs(),
            input_info2.expiration_time_ms());
}

TEST_F(CacheableResourceBaseTest, SameUrlDifferentKey) {
  SetResponseWithDefaultHeaders(kTestUrl, kContentTypeText,
                                kContent, 1000);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback);
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());

  RefCountedPtr<TestResource> resource2(new TestResource(rewrite_driver()));
  resource2->set_cache_key("http://other_key.org/");
  MockResourceCallback callback2(ResourcePtr(resource2.get()),
                                server_context()->thread_system());
  resource2->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback2);
  // 2 fetches, since we are using different keys.
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());
  EXPECT_TRUE(callback2.done());
  EXPECT_TRUE(callback2.success());

  // Both should be cached successfully now.
  resource_->Reset();
  MockResourceCallback callback3(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback3);
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());
  EXPECT_TRUE(callback3.done());
  EXPECT_TRUE(callback3.success());

  // Delete resource's cache entry to make sure that #2 is really using
  // something different.
  lru_cache()->Delete(HttpCacheKey(kTestUrl));

  // Re-fetch r1, to make sure the delete worked
  resource_->Reset();
  MockResourceCallback callback4(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback4);
  EXPECT_EQ(3, counting_url_async_fetcher()->fetch_count());
  EXPECT_TRUE(callback4.done());
  EXPECT_TRUE(callback4.success());

  // Now fetch r2, should still be hashed.
  resource2->Reset();
  MockResourceCallback callback5(ResourcePtr(resource2.get()),
                                 server_context()->thread_system());
  resource2->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback5);
  EXPECT_EQ(3, counting_url_async_fetcher()->fetch_count());
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());

  // Now test freshening, with both ops happening simultaneously to make
  // sure the locking is correct.
  SetupWaitFetcher();
  InputInfo input_info, input2_info;
  resource_->FillInPartitionInputInfo(Resource::kIncludeInputHash,
                                      &input_info);
  resource2->FillInPartitionInputInfo(Resource::kIncludeInputHash,
                                      &input2_info);

  AdvanceTimeMs(900 * Timer::kSecondMs);

  MockFreshenCallback freshen_cb(ResourcePtr(resource_.get()), &input_info);
  resource_->Freshen(&freshen_cb, message_handler());

  MockFreshenCallback freshen2_cb(ResourcePtr(resource2.get()), &input2_info);
  resource2->Freshen(&freshen2_cb, message_handler());

  CallFetcherCallbacks();

  EXPECT_EQ(5, counting_url_async_fetcher()->fetch_count());
  EXPECT_EQ(1000 * Timer::kSecondMs + timer()->NowMs(),
            input_info.expiration_time_ms());

  EXPECT_EQ(1000 * Timer::kSecondMs + timer()->NowMs(),
            input2_info.expiration_time_ms());
}

TEST_F(CacheableResourceBaseTest, PrepareHooks) {
  // Test to see that PrepareRequest works.
  SetResponseWithDefaultHeaders(kTestUrl, kContentTypeText,
                                kContent, 1000);

  MockResourceCallback callback(ResourcePtr(resource_.get()),
                                server_context()->thread_system());
  RequestContextPtr request_context(
      RequestContext::NewTestRequestContext(server_context()->thread_system()));
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       request_context, &callback);
  EXPECT_TRUE(callback.done());
  EXPECT_TRUE(callback.success());
  EXPECT_EQ(kContent, resource_->ExtractUncompressedContents());
  EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());

  // w/o the hook
  EXPECT_EQ("", mock_url_fetcher()->last_referer());
  EXPECT_FALSE(request_context->IsSessionAuthorizedFetchOrigin(kTestUrl));

  // now turn the hook on.
  resource_->Reset();
  resource_->set_do_prepare_request(true);
  lru_cache()->Delete(HttpCacheKey(kTestUrl));
  MockResourceCallback callback2(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());
  RequestContextPtr request_context2(
      RequestContext::NewTestRequestContext(server_context()->thread_system()));
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       request_context2, &callback2);
  EXPECT_TRUE(callback2.done());
  EXPECT_TRUE(callback2.success());
  EXPECT_EQ(kContent, resource_->ExtractUncompressedContents());
  EXPECT_EQ(2, counting_url_async_fetcher()->fetch_count());

  // the PrepareRequest() hook should have changed the referrer.
  EXPECT_EQ(kTestRef, mock_url_fetcher()->last_referer());

  // ... And authorized a domain
  EXPECT_TRUE(request_context2->IsSessionAuthorizedFetchOrigin(kTestUrl));

  // Now test with and without PrepareResponseHeaders

  // Set up a private resource.
  ResponseHeaders response_headers;
  SetDefaultLongCacheHeaders(&kContentTypeText, &response_headers);
  response_headers.Add(HttpAttributes::kCacheControl, "private");
  SetFetchResponse(kTestUrl, response_headers, kContent);

  MockResourceCallback callback3(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());

  resource_->Reset();
  lru_cache()->Delete(HttpCacheKey(kTestUrl));
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback3);
  EXPECT_TRUE(callback3.done());
  // By default, fetch fails.
  EXPECT_FALSE(callback3.success());
  EXPECT_EQ(3, counting_url_async_fetcher()->fetch_count());
  // Note: can't check response_headers here since resource wasn't loaded.

  // Now try with a PrepareResponseHeaders removing cache-control: private
  lru_cache()->Delete(HttpCacheKey(kTestUrl));
  resource_->set_do_prepare_response(true);
  MockResourceCallback callback4(ResourcePtr(resource_.get()),
                                 server_context()->thread_system());

  resource_->Reset();
  resource_->LoadAsync(Resource::kReportFailureIfNotCacheable,
                       RequestContext::NewTestRequestContext(
                           server_context()->thread_system()),
                       &callback4);
  EXPECT_TRUE(callback4.done());
  EXPECT_TRUE(callback4.success());  // due to messing with headers.
  EXPECT_FALSE(resource_->response_headers()->HasValue(
                   HttpAttributes::kCacheControl, "private"));
  EXPECT_EQ(4, counting_url_async_fetcher()->fetch_count());
}

}  // namespace net_instaweb