AppCaches which belong to hosted apps are not protected from deletion

chrome/browser/browsing_data_remover_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 "chrome/browser/browsing_data_remover.h"
 
 #include <set>
 
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/test/testing_profile.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/appcache/appcache.h"
-#include "webkit/appcache/appcache_group.h"
-#include "webkit/appcache/appcache_storage.h"
+#include "webkit/appcache/appcache_test_helper.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 
 namespace {
 
 const char kTestkOrigin1[] = "http://host1:1/";
 const char kTestkOrigin2[] = "http://host2:1/";
@@ skipping 130 matching lines @@
     EXPECT_TRUE(file_util::DirectoryExists(target));
   }
 
  private:
   fileapi::SandboxMountPointProvider* sandbox_;
   bool found_file_system_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveFileSystemTester);
 };
 
-// Helper class for injecting data into AppCacheStorage.
-class AppCacheInserter : public appcache::AppCacheStorage::Delegate {
- public:
-  AppCacheInserter()
-      : group_id_(0),
-        appcache_id_(0),
-        response_id_(0) {}
-  virtual ~AppCacheInserter() {}
-
-  virtual void OnGroupAndNewestCacheStored(
-      appcache::AppCacheGroup* /*group*/,
-      appcache::AppCache* /*newest_cache*/,
-      bool success,
-      bool /*would_exceed_quota*/) {
-    ASSERT_TRUE(success);
-    MessageLoop::current()->Quit();
-  }
-
-  void AddGroupAndCache(ChromeAppCacheService* appcache_service,
-                        const GURL& manifest_url) {
-    appcache::AppCacheGroup* appcache_group =
-        new appcache::AppCacheGroup(appcache_service,
-                                    manifest_url,
-                                    ++group_id_);
-    appcache::AppCache* appcache = new appcache::AppCache(appcache_service,
-                                                          ++appcache_id_);
-    appcache::AppCacheEntry entry(appcache::AppCacheEntry::MANIFEST,
-                                  ++response_id_);
-    appcache->AddEntry(manifest_url, entry);
-    appcache->set_complete(true);
-    appcache_group->AddCache(appcache);
-    appcache_service->storage()->StoreGroupAndNewestCache(appcache_group,
-                                                          appcache,
-                                                          this);
-    // OnGroupAndNewestCacheStored will quit the message loop.
-    MessageLoop::current()->Run();
-  }
-
- private:
-  int group_id_;
-  int appcache_id_;
-  int response_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(AppCacheInserter);
-};
-
-// Helper class for reading appcaches.
-class AppCacheReader {
- public:
-  explicit AppCacheReader(ChromeAppCacheService* appcache_service)
-    : appcache_service_(appcache_service),
-      ALLOW_THIS_IN_INITIALIZER_LIST(appcache_got_info_callback_(
-          this, &AppCacheReader::OnGotAppCacheInfo)) {
-  }
-
-  std::set<GURL>* ReadAppCaches() {
-    appcache_info_ = new appcache::AppCacheInfoCollection;
-    appcache_service_->GetAllAppCacheInfo(
-        appcache_info_, &appcache_got_info_callback_);
-
-    MessageLoop::current()->Run();
-    return &origins_;
-  }
-
- private:
-  void OnGotAppCacheInfo(int rv) {
-    typedef std::map<GURL, appcache::AppCacheInfoVector> InfoByOrigin;
-
-    origins_.clear();
-    for (InfoByOrigin::const_iterator origin =
-             appcache_info_->infos_by_origin.begin();
-         origin != appcache_info_->infos_by_origin.end(); ++origin) {
-      origins_.insert(origin->first);
-    }
-    MessageLoop::current()->Quit();
-  }
-
-  scoped_refptr<ChromeAppCacheService> appcache_service_;
-  net::CompletionCallbackImpl<AppCacheReader>
-      appcache_got_info_callback_;
-  scoped_refptr<appcache::AppCacheInfoCollection> appcache_info_;
-  std::set<GURL> origins_;
-
-  DISALLOW_COPY_AND_ASSIGN(AppCacheReader);
-};
-
 class BrowsingDataRemoverTest : public testing::Test {
  public:
   BrowsingDataRemoverTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         db_thread_(BrowserThread::DB, &message_loop_),
         webkit_thread_(BrowserThread::WEBKIT, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         profile_(new TestingProfile()) {
   }
@@ skipping 102 matching lines @@
   const content::ResourceContext* resource_context = NULL;
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
       new MockExtensionSpecialStoragePolicy;
   mock_policy->AddProtected(kProtectedManifest.GetOrigin());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(appcache_service.get(),
                         &ChromeAppCacheService::InitializeOnIOThread,
                         FilePath(),
                         resource_context,
-                        mock_policy,
-                        false));
+                        mock_policy));
   MessageLoop::current()->RunAllPending();
   TestingProfile* profile = GetProfile();
   profile->SetAppCacheService(appcache_service);
   profile->SetExtensionSpecialStoragePolicy(mock_policy);
 
   // Add data into the AppCacheStorage.
-  AppCacheInserter appcache_inserter;
-  appcache_inserter.AddGroupAndCache(appcache_service, kNormalManifest);
-  appcache_inserter.AddGroupAndCache(appcache_service, kProtectedManifest);
+  appcache::AppCacheTestHelper appcache_helper;
+  appcache_helper.AddGroupAndCache(appcache_service, kNormalManifest);
+  appcache_helper.AddGroupAndCache(appcache_service, kProtectedManifest);
 
   // Verify that adding the data succeeded.
-  AppCacheReader reader(appcache_service);
-  std::set<GURL>* origins = reader.ReadAppCaches();
-  EXPECT_EQ(2UL, origins->size());
-  EXPECT_TRUE(origins->find(kProtectedManifest.GetOrigin()) != origins->end());
-  EXPECT_TRUE(origins->find(kNormalManifest.GetOrigin()) != origins->end());
+  std::set<GURL> origins;
+  appcache_helper.GetOriginsWithCaches(appcache_service, &origins);
+  EXPECT_EQ(2UL, origins.size());
+  EXPECT_TRUE(origins.find(kProtectedManifest.GetOrigin()) != origins.end());
+  EXPECT_TRUE(origins.find(kNormalManifest.GetOrigin()) != origins.end());
 
   // Set up the object to be tested.
   scoped_ptr<BrowsingDataRemoverTester> tester(new BrowsingDataRemoverTester());
   BrowsingDataRemover* remover = new BrowsingDataRemover(
       profile, BrowsingDataRemover::EVERYTHING, base::Time::Now());
   remover->AddObserver(tester.get());
 
   // Remove the appcaches and wait for it to complete. BrowsingDataRemover
   // deletes itself when it completes.
   remover->Remove(BrowsingDataRemover::REMOVE_COOKIES);
   tester->BlockUntilNotified();
 
   // Results: appcaches for the normal origin got deleted, appcaches for the
   // protected origin didn't.
-  origins = reader.ReadAppCaches();
-  EXPECT_EQ(1UL, origins->size());
-  EXPECT_TRUE(origins->find(kProtectedManifest.GetOrigin()) != origins->end());
+  appcache_helper.GetOriginsWithCaches(appcache_service, &origins);
+  EXPECT_EQ(1UL, origins.size());
+  EXPECT_TRUE(origins.find(kProtectedManifest.GetOrigin()) != origins.end());
 }
 
 }  // namespace