AppCache INTERCEPT namespace.

webkit/appcache/appcache_update_job_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
@@ skipping 96 matching lines @@
       (*body) = "CACHE MANIFEST\n";
     } else if (path == "/files/explicit1") {
       (*headers) = std::string(ok_headers, arraysize(ok_headers));
       (*body) = "explicit1";
     } else if (path == "/files/explicit2") {
       (*headers) = std::string(ok_headers, arraysize(ok_headers));
       (*body) = "explicit2";
     } else if (path == "/files/fallback1a") {
       (*headers) = std::string(ok_headers, arraysize(ok_headers));
       (*body) = "fallback1a";
+    } else if (path == "/files/intercept1a") {
+      (*headers) = std::string(ok_headers, arraysize(ok_headers));
+      (*body) = "intercept1a";
     } else if (path == "/files/gone") {
       (*headers) = std::string(gone_headers, arraysize(gone_headers));
       (*body) = "";
     } else if (path == "/files/manifest1") {
       (*headers) = std::string(manifest_headers, arraysize(manifest_headers));
       (*body) = kManifest1Contents;
     } else if (path == "/files/manifest1-with-notmodified") {
       (*headers) = std::string(manifest_headers, arraysize(manifest_headers));
       (*body) = kManifest1Contents;
       (*body).append("CACHE:\n"
@@ skipping 22 matching lines @@
       (*headers) = std::string(manifest_headers, arraysize(manifest_headers));
       (*body) = "CACHE MANIFEST\n"
                 "explicit-404\n"
                 "explicit1\n"
                 "explicit2\n"
                 "explicit3\n"
                 "FALLBACK:\n"
                 "fallback1 fallback1a\n"
                 "NETWORK:\n"
                 "online1\n";
+    } else if (path == "/files/manifest-with-intercept") {
+      (*headers) = std::string(manifest_headers, arraysize(manifest_headers));
+      (*body) = "CACHE MANIFEST\n"
+                "CHROMIUM-INTERCEPT:\n"
+                "intercept1 return intercept1a\n";
     } else if (path == "/files/notmodified") {
       (*headers) = std::string(not_modified_headers,
                                arraysize(not_modified_headers));
       (*body) = "";
     } else if (path == "/files/servererror") {
       (*headers) = std::string(error_headers,
                                arraysize(error_headers));
       (*body) = "error";
     } else if (path == "/files/valid_cross_origin_https_manifest") {
       (*headers) = std::string(manifest_headers, arraysize(manifest_headers));
@@ skipping 15 matching lines @@
 };
 
 class MockHttpServerJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   virtual net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const {
     return MockHttpServer::JobFactory(request);
   }
 };
 
+inline bool operator==(const Namespace& lhs, const Namespace& rhs) {
+  return lhs.type == rhs.type &&
+         lhs.namespace_url == rhs.namespace_url &&
+         lhs.target_url == rhs.target_url;
+}
+
 }  // namespace
 
 class MockFrontend : public AppCacheFrontend {
  public:
   MockFrontend()
       : ignore_progress_events_(false), verify_progress_events_(false),
         last_progress_total_(-1), last_progress_complete_(-1),
         start_update_trigger_(CHECKING_EVENT), update_(NULL) {
   }
 
@@ skipping 801 matching lines @@
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     tested_manifest_ = MANIFEST1;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
+  void DownloadInterceptEntriesTest() {
+    // Ensures we download intercept entries too.
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+    GURL manifest_url = MockHttpServer::GetMockUrl(
+        "files/manifest-with-intercept");
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), manifest_url,
+        service_->storage()->NewGroupId());
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL());
+
+    // Set up checks for when update job finishes.
+    do_checks_after_update_finished_ = true;
+    expect_group_obsolete_ = false;
+    expect_group_has_cache_ = true;
+    tested_manifest_ = MANIFEST_WITH_INTERCEPT;
+    frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
+                               CHECKING_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
   void BasicUpgradeSuccessTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
@@ skipping 1978 matching lines @@
           break;
         case EMPTY_MANIFEST:
           VerifyEmptyManifest(cache);
           break;
         case EMPTY_FILE_MANIFEST:
           VerifyEmptyFileManifest(cache);
           break;
         case PENDING_MASTER_NO_UPDATE:
           VerifyMasterEntryNoUpdate(cache);
           break;
+        case MANIFEST_WITH_INTERCEPT:
+          VerifyManifestWithIntercept(cache);
+          break;
         case NONE:
         default:
           break;
       }
     }
   }
 
   void VerifyManifest1(AppCache* cache) {
     size_t expected = 3 + expect_extra_entries_.size();
     EXPECT_EQ(expected, cache->entries().size());
@@ skipping 13 matching lines @@
     EXPECT_EQ(AppCacheEntry::FALLBACK, entry->types());
 
     for (AppCache::EntryMap::iterator i = expect_extra_entries_.begin();
          i != expect_extra_entries_.end(); ++i) {
       entry = cache->GetEntry(i->first);
       ASSERT_TRUE(entry);
       EXPECT_EQ(i->second.types(), entry->types());
     }
 
     expected = 1;
-    EXPECT_EQ(expected, cache->fallback_namespaces_.size());
-    EXPECT_TRUE(cache->fallback_namespaces_.end() !=
-        std::find(cache->fallback_namespaces_.begin(),
-                  cache->fallback_namespaces_.end(),
-                  FallbackNamespace(
-                      MockHttpServer::GetMockUrl("files/fallback1"),
-                      MockHttpServer::GetMockUrl("files/fallback1a"))));
+    ASSERT_EQ(expected, cache->fallback_namespaces_.size());
+    EXPECT_TRUE(cache->fallback_namespaces_[0] ==
+                    Namespace(
+                        FALLBACK_NAMESPACE,
+                        MockHttpServer::GetMockUrl("files/fallback1"),
+                        MockHttpServer::GetMockUrl("files/fallback1a")));
 
     EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
     EXPECT_TRUE(cache->online_whitelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
 
   void VerifyManifestMergedTypes(AppCache* cache) {
     size_t expected = 2;
     EXPECT_EQ(expected, cache->entries().size());
     AppCacheEntry* entry = cache->GetEntry(
         MockHttpServer::GetMockUrl("files/manifest-merged-types"));
     ASSERT_TRUE(entry);
     EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::MANIFEST,
               entry->types());
     entry = cache->GetEntry(MockHttpServer::GetMockUrl("files/explicit1"));
     ASSERT_TRUE(entry);
     EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FALLBACK |
         AppCacheEntry::MASTER, entry->types());
 
     expected = 1;
-    EXPECT_EQ(expected, cache->fallback_namespaces_.size());
-    EXPECT_TRUE(cache->fallback_namespaces_.end() !=
-        std::find(cache->fallback_namespaces_.begin(),
-                  cache->fallback_namespaces_.end(),
-                  FallbackNamespace(
-                      MockHttpServer::GetMockUrl("files/fallback1"),
-                      MockHttpServer::GetMockUrl("files/explicit1"))));
+    ASSERT_EQ(expected, cache->fallback_namespaces_.size());
+    EXPECT_TRUE(cache->fallback_namespaces_[0] ==
+                    Namespace(
+                        FALLBACK_NAMESPACE,
+                        MockHttpServer::GetMockUrl("files/fallback1"),
+                        MockHttpServer::GetMockUrl("files/explicit1")));
 
     EXPECT_EQ(expected, cache->online_whitelist_namespaces_.size());
     EXPECT_TRUE(cache->online_whitelist_namespaces_.end() !=
         std::find(cache->online_whitelist_namespaces_.begin(),
                   cache->online_whitelist_namespaces_.end(),
                   MockHttpServer::GetMockUrl("files/online1")));
     EXPECT_FALSE(cache->online_whitelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
@@ skipping 55 matching lines @@
     EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::MASTER, entry->types());
     EXPECT_TRUE(entry->has_response_id());
 
     EXPECT_TRUE(cache->fallback_namespaces_.empty());
     EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
     EXPECT_FALSE(cache->online_whitelist_all_);
 
     EXPECT_TRUE(cache->update_time_ > base::Time());
   }
 
+  void VerifyManifestWithIntercept(AppCache* cache) {
+    EXPECT_EQ(2u, cache->entries().size());
+    const char* kManifestPath = "files/manifest-with-intercept";
+    AppCacheEntry* entry =
+        cache->GetEntry(MockHttpServer::GetMockUrl(kManifestPath));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::MANIFEST, entry->types());
+    entry = cache->GetEntry(MockHttpServer::GetMockUrl("files/intercept1a"));
+    ASSERT_TRUE(entry);
+    EXPECT_TRUE(entry->IsIntercept());
+    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
+    EXPECT_FALSE(cache->online_whitelist_all_);
+    EXPECT_TRUE(cache->update_time_ > base::Time());
+  }
+
  private:
   // Various manifest files used in this test.
   enum TestedManifest {
     NONE,
     MANIFEST1,
     MANIFEST_MERGED_TYPES,
     EMPTY_MANIFEST,
     EMPTY_FILE_MANIFEST,
     PENDING_MASTER_NO_UPDATE,
+    MANIFEST_WITH_INTERCEPT
   };
 
   scoped_ptr<IOThread> io_thread_;
 
   scoped_ptr<MockAppCacheService> service_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> protect_newest_cache_;
   scoped_ptr<base::WaitableEvent> event_;
 
   scoped_ptr<AppCacheResponseWriter> response_writer_;
@@ skipping 125 matching lines @@
 }
 
 TEST_F(AppCacheUpdateJobTest, UpgradeManifestDataUnchanged) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeManifestDataUnchangedTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, BasicCacheAttemptSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::BasicCacheAttemptSuccessTest);
 }
 
+TEST_F(AppCacheUpdateJobTest, DownloadInterceptEntriesTest) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::DownloadInterceptEntriesTest);
+}
+
 TEST_F(AppCacheUpdateJobTest, BasicUpgradeSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::BasicUpgradeSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, UpgradeLoadFromNewestCache) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeLoadFromNewestCacheTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, UpgradeNoLoadFromNewestCache) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeNoLoadFromNewestCacheTest);
@@ skipping 139 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache