Removes MessageLoop::Type checks in favor of IsCurrent on MessageLoops.

webkit/browser/appcache/appcache_update_job_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/base/net_errors.h"
@@ skipping 599 matching lines @@
   void RunTestOnIOThread(Method method) {
     event_.reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
         FROM_HERE, base::Bind(method, base::Unretained(this)));
 
     // Wait until task is done before exiting the test.
     event_->Wait();
   }
 
   void StartCacheAttemptTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
 
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend mock_frontend;
@@ skipping 13 matching lines @@
     EXPECT_EQ(expected, events[0].first.size());
     EXPECT_EQ(host.host_id(), events[0].first[0]);
     EXPECT_EQ(CHECKING_EVENT, events[0].second);
 
     // Abort as we're not testing actual URL fetches in this test.
     delete update;
     UpdateFinished();
   }
 
   void StartUpgradeAttemptTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     {
       MakeService();
       group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
                                  service_->storage()->NewGroupId());
 
       // Give the group some existing caches.
       AppCache* cache1 = MakeCacheForGroup(1, 111);
       AppCache* cache2 = MakeCacheForGroup(2, 222);
 
@@ skipping 46 matching lines @@
       events = mock_frontend3.raised_events_;
       EXPECT_TRUE(events.empty());
 
       // Abort as we're not testing actual URL fetches in this test.
       delete update;
     }
     UpdateFinished();
   }
 
   void CacheAttemptFetchManifestFailTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     update->manifest_fetcher_->request()->CancelWithError(-100);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeFetchManifestFailTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
@@ skipping 17 matching lines @@
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, ERROR_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestRedirectTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new RedirectFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://testme"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // redirect is like a failed request
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestMissingMimeTypeTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/missing-mime-manifest"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 17 matching lines @@
     MockFrontend::HostIds ids(1, host->host_id());
     frontend->AddExpectedEvent(ids, CHECKING_EVENT);
     frontend->AddExpectedEvent(ids, DOWNLOADING_EVENT);
     frontend->AddExpectedEvent(ids, PROGRESS_EVENT);  // final
     frontend->AddExpectedEvent(ids, UPDATE_READY_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestNotFoundTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/nosuchfile"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
@@ skipping 16 matching lines @@
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, OBSOLETE_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, OBSOLETE_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestGoneTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/gone"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void CacheAttemptNotModifiedTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/notmodified"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // treated like cache failure
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeNotModifiedTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/notmodified"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
@@ skipping 16 matching lines @@
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, NO_UPDATE_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, NO_UPDATE_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeManifestDataUnchangedTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Create response writer to get a response id.
@@ skipping 29 matching lines @@
         io_buffer.get(),
         seed_data.length(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   // See http://code.google.com/p/chromium/issues/detail?id=95101
   void Bug95101Test() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/empty-manifest"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Create a malformed cache with a missing manifest entry.
@@ skipping 25 matching lines @@
     response_writer_.reset();
 
     AppCacheUpdateJob* update = group_->update_job_;
     update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     WaitForUpdateToFinish();
   }
 
   void BasicCacheAttemptSuccessTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     GURL manifest_url = MockHttpServer::GetMockUrl("files/manifest1");
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), manifest_url,
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     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_ = MANIFEST1;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void DownloadInterceptEntriesTest() {
     // Ensures we download intercept entries too.
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
     GURL manifest_url =
         MockHttpServer::GetMockUrl("files/manifest-with-intercept");
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), manifest_url,
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     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(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Create a response writer to get a response id.
@@ skipping 40 matching lines @@
     response_writer_->WriteData(
         io_buffer.get(),
         seed_data.length(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeLoadFromNewestCacheTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
@@ skipping 42 matching lines @@
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
         io_buffer.get(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeNoLoadFromNewestCacheTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
@@ skipping 39 matching lines @@
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
         io_buffer.get(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeLoadFromNewestCacheVaryHeaderTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
@@ skipping 39 matching lines @@
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
         io_buffer.get(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeSuccessMergedTypesTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-merged-types"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
@@ skipping 30 matching lines @@
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // final
     frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void CacheAttemptFailUrlFetchTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-with-404"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // 404 explicit url is cache failure
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeFailUrlFetchTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-fb-404"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 99);
@@ skipping 20 matching lines @@
     frontend1->AddExpectedEvent(ids1, ERROR_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeFailMasterUrlFetchTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     tested_manifest_path_override_ = "files/manifest1-with-notmodified";
 
     MakeService();
     const GURL kManifestUrl =
         MockHttpServer::GetMockUrl(tested_manifest_path_override_);
     group_ = new AppCacheGroup(
         service_->storage(), kManifestUrl,
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
@@ skipping 75 matching lines @@
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // explicit2
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // servererror
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // notmodified
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // final
     frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void EmptyManifestTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/empty-manifest"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 33);
@@ skipping 23 matching lines @@
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // final
     frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void EmptyFileTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/empty-file-manifest"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 22);
@@ skipping 14 matching lines @@
     frontend->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
     frontend->AddExpectedEvent(ids1, PROGRESS_EVENT);
     frontend->AddExpectedEvent(ids1, PROGRESS_EVENT);  // final
     frontend->AddExpectedEvent(ids1, UPDATE_READY_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetryRequestTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 3 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::RETRY_AFTER_0, 4);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
@@ skipping 13 matching lines @@
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetryNoRetryAfterTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 0 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::NO_RETRY_AFTER, 1);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
@@ skipping 13 matching lines @@
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetryNonzeroRetryAfterTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set some large number of times to return retry.
     // Expect 1 request and 0 retry attempts.
     RetryRequestTestJob::Initialize(
         5, RetryRequestTestJob::NONZERO_RETRY_AFTER, 1);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
@@ skipping 14 matching lines @@
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetrySuccessTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set 2 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 2 retries, 1 url fetch, 1 manifest refetch.
     RetryRequestTestJob::Initialize(2, RetryRequestTestJob::RETRY_AFTER_0, 5);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
@@ skipping 13 matching lines @@
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetryUrlTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set 1 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 1 url fetch, 1 url retry, 1 manifest refetch.
     RetryRequestTestJob::Initialize(1, RetryRequestTestJob::RETRY_AFTER_0, 4);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
@@ skipping 12 matching lines @@
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void FailStoreNewestCacheTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     MockAppCacheStorage* storage =
         reinterpret_cast<MockAppCacheStorage*>(service_->storage());
     storage->SimulateStoreGroupAndNewestCacheFailure();
 
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     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_ = false;  // storage failed
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeFailStoreNewestCacheTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     MockAppCacheStorage* storage =
         reinterpret_cast<MockAppCacheStorage*>(service_->storage());
     storage->SimulateStoreGroupAndNewestCacheFailure();
 
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
@@ skipping 25 matching lines @@
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryFailStoreNewestCacheTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     MockAppCacheStorage* storage =
         reinterpret_cast<MockAppCacheStorage*>(service_->storage());
     storage->SimulateStoreGroupAndNewestCacheFailure();
 
     const GURL kManifestUrl = MockHttpServer::GetMockUrl("files/notmodified");
     const int64 kManifestResponseId = 11;
 
     // Seed the response_info working set with canned data for
@@ skipping 29 matching lines @@
     expect_newest_cache_ = cache.get();  // unchanged
     MockFrontend::HostIds ids1(1, host->host_id());
     frontend->AddExpectedEvent(ids1, ERROR_EVENT);
     frontend->expected_error_message_ =
         "Failed to commit new cache to storage";
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeFailMakeGroupObsoleteTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     MockAppCacheStorage* storage =
         reinterpret_cast<MockAppCacheStorage*>(service_->storage());
     storage->SimulateMakeGroupObsoleteFailure();
 
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/nosuchfile"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
@@ skipping 20 matching lines @@
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, ERROR_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryFetchManifestFailTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"), 111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->new_master_entry_url_ = GURL("http://failme/blah");
     update->StartUpdate(host, host->new_master_entry_url_);
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     update->manifest_fetcher_->request()->CancelWithError(-100);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     MockFrontend::HostIds ids1(1, host->host_id());
     frontend->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend->AddExpectedEvent(ids1, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryBadManifestTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/bad-manifest"), 111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->new_master_entry_url_ = MockHttpServer::GetMockUrl("files/blah");
     update->StartUpdate(host, host->new_master_entry_url_);
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     MockFrontend::HostIds ids1(1, host->host_id());
     frontend->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend->AddExpectedEvent(ids1, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryManifestNotFoundTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/nosuchfile"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->new_master_entry_url_ = MockHttpServer::GetMockUrl("files/blah");
 
     update->StartUpdate(host, host->new_master_entry_url_);
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     MockFrontend::HostIds ids1(1, host->host_id());
     frontend->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend->AddExpectedEvent(ids1, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryFailUrlFetchTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-fb-404"), 111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     frontend->SetIgnoreProgressEvents(true);
@@ skipping 10 matching lines @@
     expect_group_has_cache_ = false;  // 404 fallback url is cache failure
     MockFrontend::HostIds ids1(1, host->host_id());
     frontend->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
     frontend->AddExpectedEvent(ids1, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryAllFailTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 21 matching lines @@
     frontend1->AddExpectedEvent(ids1, ERROR_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeMasterEntryAllFailTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 34 matching lines @@
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
     MockFrontend::HostIds ids3(1, host3->host_id());
     frontend3->AddExpectedEvent(ids3, CHECKING_EVENT);
     frontend3->AddExpectedEvent(ids3, DOWNLOADING_EVENT);
     frontend3->AddExpectedEvent(ids3, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntrySomeFailTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 27 matching lines @@
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // final
     frontend2->AddExpectedEvent(ids2, CACHED_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeMasterEntrySomeFailTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 39 matching lines @@
     frontend3->AddExpectedEvent(ids3, DOWNLOADING_EVENT);
     frontend3->AddExpectedEvent(ids3, PROGRESS_EVENT);
     frontend3->AddExpectedEvent(ids3, PROGRESS_EVENT);
     frontend3->AddExpectedEvent(ids3, PROGRESS_EVENT);  // final
     frontend3->AddExpectedEvent(ids3, UPDATE_READY_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryNoUpdateTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/notmodified"), 111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
@@ skipping 33 matching lines @@
     frontend2->AddExpectedEvent(ids3, CHECKING_EVENT);
     MockFrontend::HostIds ids2and3;
     ids2and3.push_back(host2->host_id());
     ids2and3.push_back(host3->host_id());
     frontend2->AddExpectedEvent(ids2and3, NO_UPDATE_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void StartUpdateMidCacheAttemptTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend1 = MakeMockFrontend();
@@ skipping 66 matching lines @@
 
     // Host 5 is not associated with cache so no progress/cached events.
     MockFrontend::HostIds ids5(1, host5->host_id());
     frontend5->AddExpectedEvent(ids5, CHECKING_EVENT);
     frontend5->AddExpectedEvent(ids5, DOWNLOADING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void StartUpdateMidNoUpdateTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/notmodified"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
@@ skipping 60 matching lines @@
     frontend5->AddExpectedEvent(ids5, CHECKING_EVENT);
     frontend5->AddExpectedEvent(ids5, NO_UPDATE_EVENT);
     MockFrontend::HostIds ids6(1, host6->host_id());
     frontend6->AddExpectedEvent(ids6, CHECKING_EVENT);
     frontend6->AddExpectedEvent(ids6, NO_UPDATE_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void StartUpdateMidDownloadTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 64 matching lines @@
     frontend5->AddExpectedEvent(ids5, CHECKING_EVENT);
     frontend5->AddExpectedEvent(ids5, DOWNLOADING_EVENT);
     frontend5->AddExpectedEvent(ids5, PROGRESS_EVENT);
     frontend5->AddExpectedEvent(ids5, PROGRESS_EVENT);  // final
     frontend5->AddExpectedEvent(ids5, UPDATE_READY_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void QueueMasterEntryTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 29 matching lines @@
     frontend->AddExpectedEvent(ids1, PROGRESS_EVENT);
     frontend->AddExpectedEvent(ids1, PROGRESS_EVENT);
     frontend->AddExpectedEvent(ids1, PROGRESS_EVENT);  // final
     frontend->AddExpectedEvent(ids1, CACHED_EVENT);
 
     // Group status will be IDLE so cannot call WaitForUpdateToFinish.
     group_->AddUpdateObserver(this);
   }
 
   void IfModifiedSinceTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update =
@@ skipping 48 matching lines @@
     update->manifest_response_info_.reset(response_info);
     update->internal_state_ = AppCacheUpdateJob::REFETCH_MANIFEST;
     update->FetchManifest(false);  // not first request
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     UpdateFinished();
   }
 
   void IfModifiedSinceUpgradeTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     HttpHeadersRequestTestJob::Initialize("Sat, 29 Oct 1994 19:43:31 GMT",
                                           std::string());
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ =new AppCacheGroup(
@@ skipping 43 matching lines @@
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
         io_buffer.get(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchUpgradeTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     HttpHeadersRequestTestJob::Initialize(std::string(), "\"LadeDade\"");
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
@@ skipping 42 matching lines @@
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
         io_buffer.get(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchRefetchTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     HttpHeadersRequestTestJob::Initialize(std::string(), "\"LadeDade\"");
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), GURL("http://headertest"), 111);
@@ skipping 15 matching lines @@
     update->manifest_response_info_.reset(response_info);
     update->internal_state_ = AppCacheUpdateJob::REFETCH_MANIFEST;
     update->FetchManifest(false);  // not first request
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     UpdateFinished();
   }
 
   void MultipleHeadersRefetchTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Verify that code is correct when building multiple extra headers.
     HttpHeadersRequestTestJob::Initialize(
         "Sat, 29 Oct 1994 19:43:31 GMT", "\"LadeDade\"");
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
@@ skipping 18 matching lines @@
     update->manifest_response_info_.reset(response_info);
     update->internal_state_ = AppCacheUpdateJob::REFETCH_MANIFEST;
     update->FetchManifest(false);  // not first request
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     UpdateFinished();
   }
 
   void CrossOriginHttpsSuccessTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     GURL manifest_url = MockHttpServer::GetMockHttpsUrl(
         "files/valid_cross_origin_https_manifest");
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), manifest_url, service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     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_ = NONE;
     MockFrontend::HostIds host_ids(1, host->host_id());
     frontend->AddExpectedEvent(host_ids, CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void CrossOriginHttpsDeniedTest() {
-    ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
+    ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     GURL manifest_url = MockHttpServer::GetMockHttpsUrl(
         "files/invalid_cross_origin_https_manifest");
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), manifest_url, service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
@@ skipping 690 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache