Remove implicit conversions from scoped_refptr to T* in content/browser/service_worker

content/browser/service_worker/service_worker_storage_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 88 matching lines @@
 
   scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
   info->request_time = base::Time::Now();
   info->response_time = base::Time::Now();
   info->was_cached = false;
   info->headers = new net::HttpResponseHeaders(headers);
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
       new HttpResponseInfoIOBuffer(info.release());
 
   int rv = -1234;
-  writer->WriteInfo(info_buffer, base::Bind(&OnIOComplete, &rv));
+  writer->WriteInfo(info_buffer.get(), base::Bind(&OnIOComplete, &rv));
   base::RunLoop().RunUntilIdle();
   EXPECT_LT(0, rv);
 
   rv = -1234;
   writer->WriteData(body, length, base::Bind(&OnIOComplete, &rv));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(length, rv);
 }
 
 void WriteStringResponse(
     ServiceWorkerStorage* storage, int64 id,
     const std::string& headers,
     const std::string& body) {
   scoped_refptr<IOBuffer> body_buffer(new WrappedIOBuffer(body.data()));
-  WriteResponse(storage, id, headers, body_buffer, body.length());
+  WriteResponse(storage, id, headers, body_buffer.get(), body.length());
 }
 
 void WriteBasicResponse(ServiceWorkerStorage* storage, int64 id) {
   scoped_ptr<ServiceWorkerResponseWriter> writer =
       storage->CreateResponseWriter(id);
 
   const char kHttpHeaders[] = "HTTP/1.0 200 HONKYDORY\0Content-Length: 5\0\0";
   const char kHttpBody[] = "Hello";
   std::string headers(kHttpHeaders, arraysize(kHttpHeaders));
   WriteStringResponse(storage, id, headers, std::string(kHttpBody));
 }
 
 bool VerifyBasicResponse(ServiceWorkerStorage* storage, int64 id,
                          bool expected_positive_result) {
   const std::string kExpectedHttpBody("Hello");
   scoped_ptr<ServiceWorkerResponseReader> reader =
       storage->CreateResponseReader(id);
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
       new HttpResponseInfoIOBuffer();
   {
     TestCompletionCallback cb;
-    reader->ReadInfo(info_buffer, cb.callback());
+    reader->ReadInfo(info_buffer.get(), cb.callback());
     int rv = cb.WaitForResult();
     if (expected_positive_result)
       EXPECT_LT(0, rv);
     if (rv <= 0)
       return false;
   }
 
   std::string received_body;
   {
     const int kBigEnough = 512;
     scoped_refptr<net::IOBuffer> buffer = new IOBuffer(kBigEnough);
     TestCompletionCallback cb;
-    reader->ReadData(buffer, kBigEnough, cb.callback());
+    reader->ReadData(buffer.get(), kBigEnough, cb.callback());
     int rv = cb.WaitForResult();
     EXPECT_EQ(static_cast<int>(kExpectedHttpBody.size()), rv);
     if (rv <= 0)
       return false;
     received_body.assign(buffer->data(), rv);
   }
 
   bool status_match =
       std::string("HONKYDORY") ==
           info_buffer->http_info->headers->GetStatusText();
   bool data_match = kExpectedHttpBody == received_body;
 
   EXPECT_TRUE(status_match);
   EXPECT_TRUE(data_match);
   return status_match && data_match;
 }
 
 void WriteResponseOfSize(ServiceWorkerStorage* storage, int64 id,
                          char val, int size) {
   const char kHttpHeaders[] = "HTTP/1.0 200 HONKYDORY\00";
   std::string headers(kHttpHeaders, arraysize(kHttpHeaders));
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(size);
   memset(buffer->data(), val, size);
-  WriteResponse(storage, id, headers, buffer, size);
+  WriteResponse(storage, id, headers, buffer.get(), size);
 }
 
 }  // namespace
 
 class ServiceWorkerStorageTest : public testing::Test {
  public:
   ServiceWorkerStorageTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {
   }
 
@@ skipping 29 matching lines @@
     EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
               database->GetPurgeableResourceIds(purgeable_ids));
   }
 
  protected:
   ServiceWorkerStatusCode StoreRegistration(
       scoped_refptr<ServiceWorkerRegistration> registration,
       scoped_refptr<ServiceWorkerVersion> version) {
     bool was_called = false;
     ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
-    storage()->StoreRegistration(
-        registration, version, MakeStatusCallback(&was_called, &result));
+    storage()->StoreRegistration(registration.get(),
+                                 version.get(),
+                                 MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode DeleteRegistration(
       int64 registration_id,
       const GURL& origin) {
     bool was_called = false;
@@ skipping 13 matching lines @@
         MakeGetAllCallback(&was_called, registrations));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
   }
 
   ServiceWorkerStatusCode UpdateToActiveState(
       scoped_refptr<ServiceWorkerRegistration> registration) {
     bool was_called = false;
     ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
-    storage()->UpdateToActiveState(
-        registration, MakeStatusCallback(&was_called, &result));
+    storage()->UpdateToActiveState(registration.get(),
+                                   MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   void UpdateLastUpdateCheckTime(ServiceWorkerRegistration* registration) {
     storage()->UpdateLastUpdateCheckTime(registration);
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 49 matching lines @@
   const int64 kRegistrationId = 0;
   const int64 kVersionId = 0;
   const base::Time kToday = base::Time::Now();
   const base::Time kYesterday = kToday - base::TimeDelta::FromDays(1);
 
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // We shouldn't find anything without having stored anything.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForPattern(kScope, &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   // Store something.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
       new ServiceWorkerRegistration(
           kScope, kScript, kRegistrationId, context_ptr_);
-  scoped_refptr<ServiceWorkerVersion> live_version =
-      new ServiceWorkerVersion(
-          live_registration, kVersionId, context_ptr_);
+  scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
+      live_registration.get(), kVersionId, context_ptr_);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLED);
-  live_registration->SetWaitingVersion(live_version);
+  live_registration->SetWaitingVersion(live_version.get());
   live_registration->set_last_update_check(kYesterday);
   EXPECT_EQ(SERVICE_WORKER_OK,
             StoreRegistration(live_registration, live_version));
 
   // Now we should find it and get the live ptr back immediately.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   // But FindRegistrationForPattern is always async.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   // Can be found by id too.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
-  ASSERT_TRUE(found_registration);
+  ASSERT_TRUE(found_registration.get());
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   // Drop the live registration, but keep the version live.
   live_registration = NULL;
 
   // Now FindRegistrationForDocument should be async.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
-  ASSERT_TRUE(found_registration);
+  ASSERT_TRUE(found_registration.get());
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
-  EXPECT_EQ(live_version, found_registration->waiting_version());
+  EXPECT_EQ(live_version.get(), found_registration->waiting_version());
   found_registration = NULL;
 
   // Drop the live version too.
   live_version = NULL;
 
   // And FindRegistrationForPattern is always async.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForPattern(kScope, &found_registration));
-  ASSERT_TRUE(found_registration);
+  ASSERT_TRUE(found_registration.get());
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
   EXPECT_FALSE(found_registration->active_version());
   ASSERT_TRUE(found_registration->waiting_version());
   EXPECT_EQ(kYesterday, found_registration->last_update_check());
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED,
             found_registration->waiting_version()->status());
 
   // Update to active and update the last check time.
   scoped_refptr<ServiceWorkerVersion> temp_version =
       found_registration->waiting_version();
   temp_version->SetStatus(ServiceWorkerVersion::ACTIVATED);
-  found_registration->SetActiveVersion(temp_version);
+  found_registration->SetActiveVersion(temp_version.get());
   temp_version = NULL;
   EXPECT_EQ(SERVICE_WORKER_OK, UpdateToActiveState(found_registration));
   found_registration->set_last_update_check(kToday);
-  UpdateLastUpdateCheckTime(found_registration);
+  UpdateLastUpdateCheckTime(found_registration.get());
 
   found_registration = NULL;
 
   // Trying to update a unstored registration to active should fail.
   scoped_refptr<ServiceWorkerRegistration> unstored_registration =
       new ServiceWorkerRegistration(
           kScope, kScript, kRegistrationId + 1, context_ptr_);
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             UpdateToActiveState(unstored_registration));
   unstored_registration = NULL;
 
   // The Find methods should return a registration with an active version
   // and the expected update time.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
-  ASSERT_TRUE(found_registration);
+  ASSERT_TRUE(found_registration.get());
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
   EXPECT_FALSE(found_registration->waiting_version());
   ASSERT_TRUE(found_registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
             found_registration->active_version()->status());
   EXPECT_EQ(kToday, found_registration->last_update_check());
 
   // Delete from storage but with a instance still live.
   EXPECT_TRUE(context_->GetLiveVersion(kRegistrationId));
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId, kScope.GetOrigin()));
   EXPECT_TRUE(context_->GetLiveVersion(kRegistrationId));
 
   // Should no longer be found.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   // Deleting an unstored registration should succeed.
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId + 1, kScope.GetOrigin()));
 }
 
 TEST_F(ServiceWorkerStorageTest, InstallingRegistrationsAreFindable) {
   const GURL kScope("http://www.test.not/scope/");
   const GURL kScript("http://www.test.not/script.js");
   const GURL kDocumentUrl("http://www.test.not/scope/document.html");
   const int64 kRegistrationId = 0;
   const int64 kVersionId = 0;
 
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // Create an unstored registration.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
       new ServiceWorkerRegistration(
           kScope, kScript, kRegistrationId, context_ptr_);
-  scoped_refptr<ServiceWorkerVersion> live_version =
-      new ServiceWorkerVersion(
-          live_registration, kVersionId, context_ptr_);
+  scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
+      live_registration.get(), kVersionId, context_ptr_);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLING);
-  live_registration->SetWaitingVersion(live_version);
+  live_registration->SetWaitingVersion(live_version.get());
 
   // Should not be findable, including by GetAllRegistrations.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForPattern(kScope, &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   std::vector<ServiceWorkerRegistrationInfo> all_registrations;
   GetAllRegistrations(&all_registrations);
   EXPECT_TRUE(all_registrations.empty());
 
   // Notify storage of it being installed.
-  storage()->NotifyInstallingRegistration(live_registration);
+  storage()->NotifyInstallingRegistration(live_registration.get());
 
   // Now should be findable.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   GetAllRegistrations(&all_registrations);
   EXPECT_EQ(1u, all_registrations.size());
   all_registrations.clear();
 
   // Notify storage of installation no longer happening.
   storage()->NotifyDoneInstallingRegistration(
-      live_registration, NULL, SERVICE_WORKER_OK);
+      live_registration.get(), NULL, SERVICE_WORKER_OK);
 
   // Once again, should not be findable.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForPattern(kScope, &found_registration));
-  EXPECT_FALSE(found_registration);
+  EXPECT_FALSE(found_registration.get());
 
   GetAllRegistrations(&all_registrations);
   EXPECT_TRUE(all_registrations.empty());
 }
 
 class ServiceWorkerResourceStorageTest : public ServiceWorkerStorageTest {
  public:
   virtual void SetUp() OVERRIDE {
     ServiceWorkerStorageTest::SetUp();
 
@@ skipping 146 matching lines @@
   EXPECT_TRUE(verify_ids.empty());
 
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
 }
 
 TEST_F(ServiceWorkerResourceStorageTest, DeleteRegistration_ActiveVersion) {
   // Promote the worker to active and add a controllee.
   registration_->SetActiveVersion(registration_->waiting_version());
   storage()->UpdateToActiveState(
-      registration_, base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+      registration_.get(), base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   scoped_ptr<ServiceWorkerProviderHost> host(
       new ServiceWorkerProviderHost(33 /* dummy render process id */,
                                     1 /* dummy provider_id */,
                                     context_->AsWeakPtr(),
                                     NULL));
   registration_->active_version()->AddControllee(host.get());
 
   bool was_called = false;
   ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
   std::set<int64> verify_ids;
@@ skipping 37 matching lines @@
 #if defined(OS_ANDROID)
 #define MAYBE_CleanupOnRestart DISABLED_CleanupOnRestart
 #else
 #define MAYBE_CleanupOnRestart CleanupOnRestart
 #endif
 TEST_F(ServiceWorkerResourceStorageDiskTest, MAYBE_CleanupOnRestart) {
   // Promote the worker to active and add a controllee.
   registration_->SetActiveVersion(registration_->waiting_version());
   registration_->SetWaitingVersion(NULL);
   storage()->UpdateToActiveState(
-      registration_, base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+      registration_.get(), base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   scoped_ptr<ServiceWorkerProviderHost> host(
       new ServiceWorkerProviderHost(33 /* dummy render process id */,
                                     1 /* dummy provider_id */,
                                     context_->AsWeakPtr(),
                                     NULL));
   registration_->active_version()->AddControllee(host.get());
 
   bool was_called = false;
   ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
   std::set<int64> verify_ids;
@@ skipping 67 matching lines @@
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
   EXPECT_FALSE(
       VerifyBasicResponse(storage(), kStaleUncommittedResourceId, false));
   EXPECT_TRUE(VerifyBasicResponse(storage(), kNewResourceId, true));
 }
 
 TEST_F(ServiceWorkerResourceStorageTest, UpdateRegistration) {
   // Promote the worker to active worker and add a controllee.
   registration_->SetActiveVersion(registration_->waiting_version());
   storage()->UpdateToActiveState(
-      registration_, base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+      registration_.get(), base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   scoped_ptr<ServiceWorkerProviderHost> host(
       new ServiceWorkerProviderHost(33 /* dummy render process id */,
                                     1 /* dummy provider_id */,
                                     context_->AsWeakPtr(),
                                     NULL));
   registration_->active_version()->AddControllee(host.get());
 
   bool was_called = false;
   ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
   std::set<int64> verify_ids;
 
   // Make an updated registration.
   scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
-      registration_, storage()->NewVersionId(), context_ptr_);
+      registration_.get(), storage()->NewVersionId(), context_ptr_);
   live_version->SetStatus(ServiceWorkerVersion::NEW);
-  registration_->SetWaitingVersion(live_version);
+  registration_->SetWaitingVersion(live_version.get());
 
   // Writing the registration should move the old version's resources to the
   // purgeable list but keep them available.
   storage()->StoreRegistration(
-      registration_,
+      registration_.get(),
       registration_->waiting_version(),
       base::Bind(&VerifyPurgeableListStatusCallback,
                  base::Unretained(storage()->database_.get()),
                  &verify_ids,
                  &was_called,
                  &result));
   registration_->active_version()->Doom();
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
@@ skipping 24 matching lines @@
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // Registration for "/scope/".
   const GURL kScope1("http://www.example.com/scope/");
   const GURL kScript1("http://www.example.com/script1.js");
   const int64 kRegistrationId1 = 1;
   const int64 kVersionId1 = 1;
   scoped_refptr<ServiceWorkerRegistration> live_registration1 =
       new ServiceWorkerRegistration(
           kScope1, kScript1, kRegistrationId1, context_ptr_);
-  scoped_refptr<ServiceWorkerVersion> live_version1 =
-      new ServiceWorkerVersion(
-          live_registration1, kVersionId1, context_ptr_);
+  scoped_refptr<ServiceWorkerVersion> live_version1 = new ServiceWorkerVersion(
+      live_registration1.get(), kVersionId1, context_ptr_);
   live_version1->SetStatus(ServiceWorkerVersion::INSTALLED);
-  live_registration1->SetWaitingVersion(live_version1);
+  live_registration1->SetWaitingVersion(live_version1.get());
 
   // Registration for "/scope/foo".
   const GURL kScope2("http://www.example.com/scope/foo");
   const GURL kScript2("http://www.example.com/script2.js");
   const int64 kRegistrationId2 = 2;
   const int64 kVersionId2 = 2;
   scoped_refptr<ServiceWorkerRegistration> live_registration2 =
       new ServiceWorkerRegistration(
           kScope2, kScript2, kRegistrationId2, context_ptr_);
-  scoped_refptr<ServiceWorkerVersion> live_version2 =
-      new ServiceWorkerVersion(
-          live_registration2, kVersionId2, context_ptr_);
+  scoped_refptr<ServiceWorkerVersion> live_version2 = new ServiceWorkerVersion(
+      live_registration2.get(), kVersionId2, context_ptr_);
   live_version2->SetStatus(ServiceWorkerVersion::INSTALLED);
-  live_registration2->SetWaitingVersion(live_version2);
+  live_registration2->SetWaitingVersion(live_version2.get());
 
   // Registration for "/scope/foobar".
   const GURL kScope3("http://www.example.com/scope/foobar");
   const GURL kScript3("http://www.example.com/script3.js");
   const int64 kRegistrationId3 = 3;
   const int64 kVersionId3 = 3;
   scoped_refptr<ServiceWorkerRegistration> live_registration3 =
       new ServiceWorkerRegistration(
           kScope3, kScript3, kRegistrationId3, context_ptr_);
-  scoped_refptr<ServiceWorkerVersion> live_version3 =
-      new ServiceWorkerVersion(
-          live_registration3, kVersionId3, context_ptr_);
+  scoped_refptr<ServiceWorkerVersion> live_version3 = new ServiceWorkerVersion(
+      live_registration3.get(), kVersionId3, context_ptr_);
   live_version3->SetStatus(ServiceWorkerVersion::INSTALLED);
-  live_registration3->SetWaitingVersion(live_version3);
+  live_registration3->SetWaitingVersion(live_version3.get());
 
   // Notify storage of they being installed.
-  storage()->NotifyInstallingRegistration(live_registration1);
-  storage()->NotifyInstallingRegistration(live_registration2);
-  storage()->NotifyInstallingRegistration(live_registration3);
+  storage()->NotifyInstallingRegistration(live_registration1.get());
+  storage()->NotifyInstallingRegistration(live_registration2.get());
+  storage()->NotifyInstallingRegistration(live_registration3.get());
 
   // Find a registration among installing ones.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration2, found_registration);
   found_registration = NULL;
 
   // Store registrations.
   EXPECT_EQ(SERVICE_WORKER_OK,
             StoreRegistration(live_registration1, live_version1));
   EXPECT_EQ(SERVICE_WORKER_OK,
             StoreRegistration(live_registration2, live_version2));
   EXPECT_EQ(SERVICE_WORKER_OK,
             StoreRegistration(live_registration3, live_version3));
 
   // Notify storage of installations no longer happening.
   storage()->NotifyDoneInstallingRegistration(
-      live_registration1, NULL, SERVICE_WORKER_OK);
+      live_registration1.get(), NULL, SERVICE_WORKER_OK);
   storage()->NotifyDoneInstallingRegistration(
-      live_registration2, NULL, SERVICE_WORKER_OK);
+      live_registration2.get(), NULL, SERVICE_WORKER_OK);
   storage()->NotifyDoneInstallingRegistration(
-      live_registration3, NULL, SERVICE_WORKER_OK);
+      live_registration3.get(), NULL, SERVICE_WORKER_OK);
 
   // Find a registration among installed ones.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration2, found_registration);
 }
 
 TEST_F(ServiceWorkerStorageTest, CompareResources) {
   // Compare two small responses containing the same data.
   WriteBasicResponse(storage(), 1);
@@ skipping 50 matching lines @@
   are_equal = true;
   storage()->CompareScriptResources(
       5, 6,
       base::Bind(&OnCompareComplete, &status, &are_equal));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_FALSE(are_equal);
 }
 
 }  // namespace content