Move remaining webkit storage unit tests to content_unittests

webkit/appcache/appcache_group_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 <string>
 
+#include "base/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_host.h"
 #include "webkit/appcache/mock_appcache_service.h"
 #include "webkit/appcache/appcache_update_job.h"
 #include "webkit/appcache/appcache_interfaces.h"
 
 namespace {
 
@@ skipping 71 matching lines @@
   }
 
   virtual void OnUpdateComplete(AppCacheGroup* group) {
     update_completed_ = true;
   }
 
   bool update_completed_;
 };
 
 class AppCacheGroupTest : public testing::Test {
+ private:
+  MessageLoop message_loop_;
 };
 
-TEST(AppCacheGroupTest, AddRemoveCache) {
+TEST_F(AppCacheGroupTest, AddRemoveCache) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   base::Time now = base::Time::Now();
 
   scoped_refptr<AppCache> cache1(new AppCache(&service, 111));
   cache1->set_complete(true);
   cache1->set_update_time(now);
   group->AddCache(cache1);
@@ skipping 48 matching lines @@
   // Can remove newest cache if there are older caches.
   group->AddCache(cache1);
   EXPECT_EQ(cache1, group->newest_complete_cache());
   group->AddCache(cache4);
   EXPECT_EQ(cache4, group->newest_complete_cache());
   group->RemoveCache(cache4);  // remove newest
   EXPECT_FALSE(cache4->owning_group());
   EXPECT_FALSE(group->newest_complete_cache());  // newest removed
 }
 
-TEST(AppCacheGroupTest, CleanupUnusedGroup) {
+TEST_F(AppCacheGroupTest, CleanupUnusedGroup) {
   MockAppCacheService service;
   TestAppCacheFrontend frontend;
   AppCacheGroup* group =
       new AppCacheGroup(&service, GURL("http://foo.com"), 111);
 
   AppCacheHost host1(1, &frontend, &service);
   AppCacheHost host2(2, &frontend, &service);
 
   base::Time now = base::Time::Now();
 
@@ skipping 20 matching lines @@
   EXPECT_EQ(cache2, group->newest_complete_cache());
 
   // Unassociate all hosts from older cache.
   host1.AssociateNoCache(GURL());
   host2.AssociateNoCache(GURL());
   EXPECT_EQ(frontend.last_host_id_, host2.host_id());
   EXPECT_EQ(frontend.last_cache_id_, appcache::kNoCacheId);
   EXPECT_EQ(frontend.last_status_, appcache::UNCACHED);
 }
 
-TEST(AppCacheGroupTest, StartUpdate) {
+TEST_F(AppCacheGroupTest, StartUpdate) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
   group->StartUpdate();
   AppCacheUpdateJob* update = group->update_job_;
   EXPECT_TRUE(update != NULL);
 
   // Start another update, check that same update job is in use.
   group->StartUpdateWithHost(NULL);
   EXPECT_EQ(update, group->update_job_);
 
   // Deleting the update should restore the group to IDLE.
   delete update;
   EXPECT_TRUE(group->update_job_ == NULL);
   EXPECT_EQ(AppCacheGroup::IDLE, group->update_status());
 }
 
-TEST(AppCacheGroupTest, CancelUpdate) {
+TEST_F(AppCacheGroupTest, CancelUpdate) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
   group->StartUpdate();
   AppCacheUpdateJob* update = group->update_job_;
   EXPECT_TRUE(update != NULL);
 
   // Deleting the group should cancel the update.
   TestUpdateObserver observer;
   group->AddUpdateObserver(&observer);
   group = NULL;  // causes group to be deleted
   EXPECT_TRUE(observer.update_completed_);
   EXPECT_FALSE(observer.group_has_cache_);
 }
 
-TEST(AppCacheGroupTest, QueueUpdate) {
+TEST_F(AppCacheGroupTest, QueueUpdate) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
   group->StartUpdate();
   EXPECT_TRUE(group->update_job_);
 
   // Pretend group's update job is terminating so that next update is queued.
@@ skipping 28 matching lines @@
   EXPECT_TRUE(group->FindObserver(&host, group->observers_));
 
   // Delete update to cause it to complete. Verify host is notified.
   delete group->update_job_;
   EXPECT_EQ(AppCacheGroup::IDLE, group->update_status_);
   EXPECT_TRUE(group->restart_update_task_.IsCancelled());
   EXPECT_TRUE(host.update_completed_);
 }
 
 }  // namespace appcache