webkit: Use base::MessageLoop.

webkit/appcache/appcache_service_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
@@ skipping 49 matching lines @@
       return;
     }
     DCHECK(buf_len >= data_size_);
     memcpy(buf->data(), data_, data_size_);
     ScheduleUserCallback(data_size_);
     data_size_ = 0;
   }
 
  private:
   void ScheduleUserCallback(int result) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MockResponseReader::InvokeUserCompletionCallback,
-                   weak_factory_.GetWeakPtr(), result));
+                   weak_factory_.GetWeakPtr(),

[brettw, 2013/04/30 21:56:47]

"

[xhwang, 2013/05/06 16:33:12]

Done.

[xhwang, 2013/05/06 16:33:12]

Done.

+                   result));
   }
 
   scoped_ptr<net::HttpResponseInfo> info_;
   int info_size_;
   const char* data_;
   int data_size_;
 };
 
 }  // namespace
 
@@ skipping 87 matching lines @@
 
   const GURL kOrigin;
   const GURL kManifestUrl;
 
   scoped_ptr<AppCacheService> service_;
   int delete_result_;
   int delete_completion_count_;
   net::CompletionCallback deletion_callback_;
 
  private:
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 };
 
 TEST_F(AppCacheServiceTest, DeleteAppCachesForOrigin) {
   // Without giving mock storage simiulated info, should fail.
   service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
   EXPECT_EQ(0, delete_completion_count_);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
   EXPECT_EQ(net::ERR_FAILED, delete_result_);
   delete_completion_count_ = 0;
 
   // Should succeed given an empty info collection.
   mock_storage()->SimulateGetAllInfo(new AppCacheInfoCollection);
   service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
   EXPECT_EQ(0, delete_completion_count_);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
   EXPECT_EQ(net::OK, delete_result_);
   delete_completion_count_ = 0;
 
   scoped_refptr<AppCacheInfoCollection> info(new AppCacheInfoCollection);
 
   // Should succeed given a non-empty info collection.
   AppCacheInfo mock_manifest_1;
   AppCacheInfo mock_manifest_2;
   AppCacheInfo mock_manifest_3;
   mock_manifest_1.manifest_url = kOrigin.Resolve("manifest1");
   mock_manifest_2.manifest_url = kOrigin.Resolve("manifest2");
   mock_manifest_3.manifest_url = kOrigin.Resolve("manifest3");
   AppCacheInfoVector info_vector;
   info_vector.push_back(mock_manifest_1);
   info_vector.push_back(mock_manifest_2);
   info_vector.push_back(mock_manifest_3);
   info->infos_by_origin[kOrigin] = info_vector;
   mock_storage()->SimulateGetAllInfo(info);
   service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
   EXPECT_EQ(0, delete_completion_count_);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
   EXPECT_EQ(net::OK, delete_result_);
   delete_completion_count_ = 0;
 
   // Should fail if storage fails to delete.
   info->infos_by_origin[kOrigin] = info_vector;
   mock_storage()->SimulateGetAllInfo(info);
   mock_storage()->SimulateMakeGroupObsoleteFailure();
   service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
   EXPECT_EQ(0, delete_completion_count_);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
   EXPECT_EQ(net::ERR_FAILED, delete_result_);
   delete_completion_count_ = 0;
 
   // Should complete with abort error if the service is deleted
   // prior to a delete completion.
   service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
   EXPECT_EQ(0, delete_completion_count_);
   service_.reset();  // kill it
   EXPECT_EQ(1, delete_completion_count_);
   EXPECT_EQ(net::ERR_ABORTED, delete_result_);
   delete_completion_count_ = 0;
 
   // Let any tasks lingering from the sudden deletion run and verify
   // no other completion calls occur.
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, delete_completion_count_);
 }
 
 TEST_F(AppCacheServiceTest, CheckAppCacheResponse) {
   // Check a non-existing manifest.
   EXPECT_FALSE(IsGroupStored(kManifestUrl));
   service_->CheckAppCacheResponse(kManifestUrl, 1, 1);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, CountPendingHelpers());
   EXPECT_FALSE(IsGroupStored(kManifestUrl));
   ResetStorage();
 
   // Check a response that looks good.
   // Nothing should be deleted.
   SetupMockGroup();
   EXPECT_TRUE(IsGroupStored(kManifestUrl));
   SetupMockReader(true, true, true);
   service_->CheckAppCacheResponse(kManifestUrl, kMockCacheId, kMockResponseId);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, CountPendingHelpers());
   EXPECT_TRUE(IsGroupStored(kManifestUrl));
   ResetStorage();
 
   // Check a response for which there is no cache entry.
   // The group should get deleted.
   SetupMockGroup();
   service_->CheckAppCacheResponse(kManifestUrl, kMockCacheId,
                                   kMissingResponseId);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, CountPendingHelpers());
   EXPECT_FALSE(IsGroupStored(kManifestUrl));
   ResetStorage();
 
   // Check a response for which there is no manifest entry in a newer version
   // of the cache. Nothing should get deleted in this case.
   SetupMockGroup();
   service_->CheckAppCacheResponse(kManifestUrl, kMissingCacheId,
                                   kMissingResponseId);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, CountPendingHelpers());
   EXPECT_TRUE(IsGroupStored(kManifestUrl));
   ResetStorage();
 
   // Check a response with bad headers.
   SetupMockGroup();
   service_->CheckAppCacheResponse(kManifestUrl, kMockCacheId, kMockResponseId);
   SetupMockReader(false, true, true);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, CountPendingHelpers());
   EXPECT_FALSE(IsGroupStored(kManifestUrl));
   ResetStorage();
 
   // Check a response with bad data.
   SetupMockGroup();
   service_->CheckAppCacheResponse(kManifestUrl, kMockCacheId, kMockResponseId);
   SetupMockReader(true, false, true);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, CountPendingHelpers());
   EXPECT_FALSE(IsGroupStored(kManifestUrl));
   ResetStorage();
 
   // Check a response with truncated data.
   SetupMockGroup();
   service_->CheckAppCacheResponse(kManifestUrl, kMockCacheId, kMockResponseId);
   SetupMockReader(true, true, false);
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, CountPendingHelpers());
   EXPECT_FALSE(IsGroupStored(kManifestUrl));
   ResetStorage();
 
   service_.reset();  // Clean up.
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace appcache