Update webkit/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

webkit/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 "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 606 matching lines @@
     event_->Wait();
   }
 
   void StartCacheAttemptTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
 
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend mock_frontend;
     AppCacheHost host(1, &mock_frontend, service_.get());
 
     update->StartUpdate(&host, GURL());
 
     // Verify state.
     EXPECT_EQ(AppCacheUpdateJob::CACHE_ATTEMPT, update->update_type_);
     EXPECT_EQ(AppCacheUpdateJob::FETCH_MANIFEST, update->internal_state_);
@@ skipping 33 matching lines @@
       host1.AssociateCompleteCache(cache1);
 
       AppCacheHost host2(2, &mock_frontend2, service_.get());
       host2.AssociateCompleteCache(cache2);
 
       AppCacheHost host3(3, &mock_frontend1, service_.get());
       host3.AssociateCompleteCache(cache1);
 
       AppCacheHost host4(4, &mock_frontend3, service_.get());
 
-      AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+      AppCacheUpdateJob* update =
+          new AppCacheUpdateJob(service_.get(), group_.get());
       group_->update_job_ = update;
       update->StartUpdate(&host4, GURL());
 
       // Verify state after starting an update.
       EXPECT_EQ(AppCacheUpdateJob::UPGRADE_ATTEMPT, update->update_type_);
       EXPECT_EQ(AppCacheUpdateJob::FETCH_MANIFEST, update->internal_state_);
       EXPECT_EQ(AppCacheGroup::CHECKING, group_->update_status());
 
       // Verify notifications.
       MockFrontend::RaisedEvents& events = mock_frontend1.raised_events_;
@@ skipping 23 matching lines @@
     }
     UpdateFinished();
   }
 
   void CacheAttemptFetchManifestFailTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 21 matching lines @@
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     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_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/missing-mime-manifest"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 33);
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->AssociateCompleteCache(cache);
 
     frontend->SetVerifyProgressEvents(true);
 
     update->StartUpdate(NULL, GURL());
@@ skipping 15 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void ManifestNotFoundTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/nosuchfile"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 15 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void ManifestGoneTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/gone"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/notmodified"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/notmodified"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 15 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void UpgradeManifestDataUnchangedTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Create response writer to get a response id.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
                                                   group_->group_id()));
 
     AppCache* cache = MakeCacheForGroup(1, response_writer_->response_id());
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
@@ skipping 12 matching lines @@
     frontend1->AddExpectedEvent(ids1, NO_UPDATE_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, NO_UPDATE_EVENT);
 
     // Seed storage with expected manifest data.
     const std::string seed_data(kManifest1Contents);
     scoped_refptr<net::StringIOBuffer> io_buffer(
         new net::StringIOBuffer(seed_data));
     response_writer_->WriteData(
-        io_buffer, seed_data.length(),
+        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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/empty-manifest"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Create a malformed cache with a missing manifest entry.
     GURL wrong_manifest_url =
         MockHttpServer::GetMockUrl("files/missing-mime-manifest");
     AppCache* cache = MakeCacheForGroup(1, wrong_manifest_url, 111);
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->AssociateCompleteCache(cache);
 
@@ skipping 26 matching lines @@
 
   void BasicCacheAttemptSuccessTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     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_);
+    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());
     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_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Create a response writer to get a response id.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
                                                   group_->group_id()));
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(),
                                         response_writer_->response_id());
     MockFrontend* frontend1 = MakeMockFrontend();
@@ skipping 24 matching lines @@
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // final
     frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
 
     // Seed storage with expected manifest data different from manifest1.
     const std::string seed_data("different");
     scoped_refptr<net::StringIOBuffer> io_buffer(
         new net::StringIOBuffer(seed_data));
     response_writer_->WriteData(
-        io_buffer, seed_data.length(),
+        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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->AssociateCompleteCache(cache);
 
     // Give the newest cache an entry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
@@ skipping 27 matching lines @@
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
-        io_buffer,
+        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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->AssociateCompleteCache(cache);
 
     // Give the newest cache an entry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
@@ skipping 24 matching lines @@
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
-        io_buffer,
+        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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->AssociateCompleteCache(cache);
 
     // Give the newest cache an entry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
@@ skipping 24 matching lines @@
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
-        io_buffer,
+        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());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-merged-types"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 29 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void CacheAttemptFailUrlFetchTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-with-404"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-fb-404"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 99);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     frontend1->SetIgnoreProgressEvents(true);
     frontend2->SetIgnoreProgressEvents(true);
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
@@ skipping 23 matching lines @@
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     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 = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 25);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 70 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void EmptyManifestTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/empty-manifest"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 33);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 22 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void EmptyFileTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/empty-file-manifest"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 22);
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->AssociateCompleteCache(cache);
     frontend->SetVerifyProgressEvents(true);
 
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
@@ skipping 21 matching lines @@
     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();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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;
@@ skipping 12 matching lines @@
     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();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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;
@@ skipping 13 matching lines @@
         5, RetryRequestTestJob::NONZERO_RETRY_AFTER, 1);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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;
@@ skipping 12 matching lines @@
     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();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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;
@@ skipping 11 matching lines @@
     // 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();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://retryurl"),
                                service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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_ = true;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void FailStoreNewestCacheTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     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_);
+    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());
 
     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_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 11);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 54 matching lines @@
     host->first_party_url_ = kManifestUrl;
     host->SelectCache(MockHttpServer::GetMockUrl("files/empty1"),
                       kNoCacheId, kManifestUrl);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     tested_manifest_ = EMPTY_MANIFEST;
     tested_manifest_path_override_ = "files/notmodified";
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
-    expect_newest_cache_ = cache;  // unchanged
+    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());
 
     MakeService();
     MockAppCacheStorage* storage =
         reinterpret_cast<MockAppCacheStorage*>(service_->storage());
     storage->SimulateMakeGroupObsoleteFailure();
 
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/nosuchfile"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
@@ skipping 13 matching lines @@
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryFetchManifestFailTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"), 111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/bad-manifest"), 111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/nosuchfile"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    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());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-fb-404"), 111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     frontend->SetIgnoreProgressEvents(true);
     AppCacheHost* host = MakeHost(1, frontend);
     host->new_master_entry_url_ =
         MockHttpServer::GetMockUrl("files/explicit1");
 
     update->StartUpdate(host, host->new_master_entry_url_);
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
@@ skipping 11 matching lines @@
   }
 
   void MasterEntryAllFailTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend1 = MakeMockFrontend();
     frontend1->SetIgnoreProgressEvents(true);
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->new_master_entry_url_ =
         MockHttpServer::GetMockUrl("files/nosuchfile");
     update->StartUpdate(host1, host1->new_master_entry_url_);
 
     MockFrontend* frontend2 = MakeMockFrontend();
@@ skipping 20 matching lines @@
   }
 
   void UpgradeMasterEntryAllFailTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend1 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->AssociateCompleteCache(cache);
 
     MockFrontend* frontend2 = MakeMockFrontend();
     frontend2->SetIgnoreProgressEvents(true);
     AppCacheHost* host2 = MakeHost(2, frontend2);
@@ skipping 33 matching lines @@
   }
 
   void MasterEntrySomeFailTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend1 = MakeMockFrontend();
     frontend1->SetIgnoreProgressEvents(true);
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->new_master_entry_url_ =
         MockHttpServer::GetMockUrl("files/nosuchfile");
     update->StartUpdate(host1, host1->new_master_entry_url_);
 
     MockFrontend* frontend2 = MakeMockFrontend();
@@ skipping 26 matching lines @@
   }
 
   void UpgradeMasterEntrySomeFailTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend1 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->AssociateCompleteCache(cache);
 
     MockFrontend* frontend2 = MakeMockFrontend();
     frontend2->SetIgnoreProgressEvents(true);
     AppCacheHost* host2 = MakeHost(2, frontend2);
@@ skipping 36 matching lines @@
 
     WaitForUpdateToFinish();
   }
 
   void MasterEntryNoUpdateTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/notmodified"), 111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->AssociateCompleteCache(cache);
 
     // Give cache an existing entry that can also be fetched.
     cache->AddEntry(MockHttpServer::GetMockUrl("files/explicit2"),
                     AppCacheEntry(AppCacheEntry::EXPLICIT, 222));
@@ skipping 33 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void StartUpdateMidCacheAttemptTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/manifest1"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend1 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->new_master_entry_url_ =
         MockHttpServer::GetMockUrl("files/explicit2");
     update->StartUpdate(host1, host1->new_master_entry_url_);
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up additional updates to be started while update is in progress.
@@ skipping 65 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void StartUpdateMidNoUpdateTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), MockHttpServer::GetMockUrl("files/notmodified"),
         service_->storage()->NewGroupId());
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->AssociateCompleteCache(cache);
 
     // Give cache an existing entry.
     cache->AddEntry(MockHttpServer::GetMockUrl("files/explicit2"),
                     AppCacheEntry(AppCacheEntry::EXPLICIT, 222));
@@ skipping 60 matching lines @@
   }
 
   void StartUpdateMidDownloadTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend1 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->AssociateCompleteCache(cache);
 
     update->StartUpdate(NULL, GURL());
 
     // Set up additional updates to be started while update is in progress.
@@ skipping 63 matching lines @@
   }
 
   void QueueMasterEntryTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Pretend update job has been running and is about to terminate.
     group_->update_status_ = AppCacheGroup::DOWNLOADING;
     update->internal_state_ = AppCacheUpdateJob::REFETCH_MANIFEST;
     EXPECT_TRUE(update->IsTerminating());
 
     // Start an update. Should be queued.
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
@@ skipping 31 matching lines @@
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     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 = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // First test against a cache attempt. Will start manifest fetch
     // synchronously.
     HttpHeadersRequestTestJob::Initialize(std::string(), std::string());
     MockFrontend mock_frontend;
     AppCacheHost host(1, &mock_frontend, service_.get());
     update->StartUpdate(&host, GURL());
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     // Now simulate a refetch manifest request. Will start fetch request
     // synchronously.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->headers = headers;  // adds ref to headers
 
     HttpHeadersRequestTestJob::Initialize(std::string(), std::string());
-    update = new AppCacheUpdateJob(service_.get(), group_);
+    update = new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
     group_->update_status_ = AppCacheGroup::DOWNLOADING;
     update->manifest_response_info_.reset(response_info);
     update->internal_state_ = AppCacheUpdateJob::REFETCH_MANIFEST;
     update->FetchManifest(false);  // not first request
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     // Change the headers to include a Last-Modified header. Manifest refetch
     // should include If-Modified-Since header.
     const char data2[] =
         "HTTP/1.1 200 OK\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
         "\0";
     net::HttpResponseHeaders* headers2 =
         new net::HttpResponseHeaders(std::string(data2, arraysize(data2)));
     response_info = new net::HttpResponseInfo();
     response_info->headers = headers2;
 
     HttpHeadersRequestTestJob::Initialize("Sat, 29 Oct 1994 19:43:31 GMT",
                                           std::string());
-    update = new AppCacheUpdateJob(service_.get(), group_);
+    update = new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
     group_->update_status_ = AppCacheGroup::DOWNLOADING;
     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());
 
     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(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Give the newest cache a manifest enry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
                                                   group_->group_id()));
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(),
                                         response_writer_->response_id());
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 20 matching lines @@
         "HTTP/1.1 200 OK\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
-        io_buffer,
+        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());
 
     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(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Give the newest cache a manifest enry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
                                                   group_->group_id()));
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(),
                                         response_writer_->response_id());
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 20 matching lines @@
         "HTTP/1.1 200 OK\0"
         "ETag: \"LadeDade\"\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
     response_writer_->WriteInfo(
-        io_buffer,
+        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());
 
     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);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "ETag: \"LadeDade\"\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
@@ skipping 16 matching lines @@
     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();
     group_ = new AppCacheGroup(
         service_->storage(), GURL("http://headertest"), 111);
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    AppCacheUpdateJob* update =
+        new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
         "ETag: \"LadeDade\"\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
@@ skipping 12 matching lines @@
 
   void CrossOriginHttpsSuccessTest() {
     ASSERT_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type());
 
     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_);
+    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());
 
     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_);
+    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;
@@ skipping 75 matching lines @@
 
   AppCacheResponseInfo* MakeAppCacheResponseInfo(
       const GURL& manifest_url, int64 response_id,
       const std::string& raw_headers) {
     net::HttpResponseInfo* http_info = new net::HttpResponseInfo();
     http_info->headers = new net::HttpResponseHeaders(raw_headers);
     scoped_refptr<AppCacheResponseInfo> info(
         new AppCacheResponseInfo(service_.get(), manifest_url,
                                  response_id, http_info, 0));
     response_infos_.push_back(info);
-    return info;
+    return info.get();
   }
 
   MockFrontend* MakeMockFrontend() {
     MockFrontend* frontend = new MockFrontend();
     frontends_.push_back(frontend);
     return frontend;
   }
 
   // Verifies conditions about the group and notifications after an update
   // has finished. Cannot verify update job internals as update is deleted.
@@ skipping 21 matching lines @@
         EXPECT_TRUE(group_->old_caches().end() ==
             std::find(group_->old_caches().begin(),
                       group_->old_caches().end(), expect_newest_cache_));
       } else {
         // Tests that don't know which newest cache to expect contain updates
         // that succeed (because the update creates a new cache whose pointer
         // is unknown to the test). Check group and newest cache were stored
         // when update succeeds.
         MockAppCacheStorage* storage =
             reinterpret_cast<MockAppCacheStorage*>(service_->storage());
-        EXPECT_TRUE(storage->IsGroupStored(group_));
+        EXPECT_TRUE(storage->IsGroupStored(group_.get()));
         EXPECT_TRUE(storage->IsCacheStored(group_->newest_complete_cache()));
 
         // Check that all entries in the newest cache were stored.
         const AppCache::EntryMap& entries =
             group_->newest_complete_cache()->entries();
         for (AppCache::EntryMap::const_iterator it = entries.begin();
              it != entries.end(); ++it) {
           EXPECT_NE(kNoResponseId, it->second.response_id());
 
           // Check that any copied entries have the expected response id
@@ skipping 272 matching lines @@
   AppCache::EntryMap expect_extra_entries_;
   std::map<GURL, int64> expect_response_ids_;
 };
 
 TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), GURL("http://manifesturl.com"),
                         service.storage()->NewGroupId()));
 
-  AppCacheUpdateJob update(&service, group);
+  AppCacheUpdateJob update(&service, group.get());
 
   // Pretend group is in checking state.
   group->update_job_ = &update;
   group->update_status_ = AppCacheGroup::CHECKING;
 
   update.StartUpdate(NULL, GURL());
   EXPECT_EQ(AppCacheGroup::CHECKING, group->update_status());
 
   MockFrontend mock_frontend;
   AppCacheHost host(1, &mock_frontend, &service);
   update.StartUpdate(&host, GURL());
 
   MockFrontend::RaisedEvents events = mock_frontend.raised_events_;
   size_t expected = 1;
   EXPECT_EQ(expected, events.size());
   EXPECT_EQ(expected, events[0].first.size());
   EXPECT_EQ(host.host_id(), events[0].first[0]);
   EXPECT_EQ(CHECKING_EVENT, events[0].second);
   EXPECT_EQ(AppCacheGroup::CHECKING, group->update_status());
 }
 
 TEST_F(AppCacheUpdateJobTest, AlreadyDownloading) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), GURL("http://manifesturl.com"),
                         service.storage()->NewGroupId()));
 
-  AppCacheUpdateJob update(&service, group);
+  AppCacheUpdateJob update(&service, group.get());
 
   // Pretend group is in downloading state.
   group->update_job_ = &update;
   group->update_status_ = AppCacheGroup::DOWNLOADING;
 
   update.StartUpdate(NULL, GURL());
   EXPECT_EQ(AppCacheGroup::DOWNLOADING, group->update_status());
 
   MockFrontend mock_frontend;
   AppCacheHost host(1, &mock_frontend, &service);
@@ skipping 222 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache