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

content/browser/service_worker/service_worker_storage.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 "content/browser/service_worker/service_worker_storage.h"
 
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
@@ skipping 106 matching lines @@
   lhs_buffer_ = new net::IOBuffer(kBufferSize);
   lhs_info_ = new HttpResponseInfoIOBuffer();
   rhs_buffer_ = new net::IOBuffer(kBufferSize);
   rhs_info_ = new HttpResponseInfoIOBuffer();
 
   ReadInfos();
 }
 
 void ResponseComparer::ReadInfos() {
   lhs_reader_->ReadInfo(
-      lhs_info_,
-      base::Bind(&ResponseComparer::OnReadInfoComplete,
-                 this));
+      lhs_info_.get(), base::Bind(&ResponseComparer::OnReadInfoComplete, this));
   rhs_reader_->ReadInfo(
-      rhs_info_,
-      base::Bind(&ResponseComparer::OnReadInfoComplete,
-                 this));
+      rhs_info_.get(), base::Bind(&ResponseComparer::OnReadInfoComplete, this));
 }
 
 void ResponseComparer::OnReadInfoComplete(int result) {
   if (completion_callback_.is_null() || !owner_)
     return;
   if (result < 0) {
     completion_callback_.Run(SERVICE_WORKER_ERROR_FAILED, false);
     completion_callback_.Reset();
     return;
   }
   if (++completion_count_ != 2)
     return;
 
   if (lhs_info_->response_data_size != rhs_info_->response_data_size) {
     completion_callback_.Run(SERVICE_WORKER_OK, false);
     return;
   }
   ReadSomeData();
 }
 
 void ResponseComparer::ReadSomeData() {
   completion_count_ = 0;
   lhs_reader_->ReadData(
-      lhs_buffer_,
+      lhs_buffer_.get(),
       kBufferSize,
       base::Bind(&ResponseComparer::OnReadDataComplete, this));
   rhs_reader_->ReadData(
-      rhs_buffer_,
+      rhs_buffer_.get(),
       kBufferSize,
       base::Bind(&ResponseComparer::OnReadDataComplete, this));
 }
 
 void ResponseComparer::OnReadDataComplete(int result) {
   if (completion_callback_.is_null() || !owner_)
     return;
   if (result < 0) {
     completion_callback_.Run(SERVICE_WORKER_ERROR_FAILED, false);
     completion_callback_.Reset();
@@ skipping 68 matching lines @@
 
 // static
 scoped_ptr<ServiceWorkerStorage> ServiceWorkerStorage::Create(
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerStorage* old_storage) {
   return make_scoped_ptr(
       new ServiceWorkerStorage(old_storage->path_,
                                context,
                                old_storage->database_task_runner_,
                                old_storage->disk_cache_thread_,
-                               old_storage->quota_manager_proxy_));
+                               old_storage->quota_manager_proxy_.get()));
 }
 
 void ServiceWorkerStorage::FindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback) {
   DCHECK(!document_url.has_ref());
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForDocument,
           weak_factory_.GetWeakPtr(), document_url, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(scoped_refptr<ServiceWorkerRegistration>(),
                       SERVICE_WORKER_ERROR_FAILED, callback);
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   // See if there are any stored registrations for the origin.
   if (!ContainsKey(registered_origins_, document_url.GetOrigin())) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForDocument(document_url);
-    CompleteFindNow(
-        installing_registration,
-        installing_registration ?
-            SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
-        callback);
+    CompleteFindNow(installing_registration,
+                    installing_registration.get()
+                        ? SERVICE_WORKER_OK
+                        : SERVICE_WORKER_ERROR_NOT_FOUND,
+                    callback);
     return;
   }
 
   database_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &FindForDocumentInDB,
           database_.get(),
           base::MessageLoopProxy::current(),
           document_url,
@@ skipping 13 matching lines @@
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   // See if there are any stored registrations for the origin.
   if (!ContainsKey(registered_origins_, scope.GetOrigin())) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForPattern(scope);
-    CompleteFindSoon(
-        FROM_HERE, installing_registration,
-        installing_registration ?
-            SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
-        callback);
+    CompleteFindSoon(FROM_HERE,
+                     installing_registration,
+                     installing_registration.get()
+                         ? SERVICE_WORKER_OK
+                         : SERVICE_WORKER_ERROR_NOT_FOUND,
+                     callback);
     return;
   }
 
   database_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &FindForPatternInDB,
           database_.get(),
           base::MessageLoopProxy::current(),
           scope,
           base::Bind(&ServiceWorkerStorage::DidFindRegistrationForPattern,
                      weak_factory_.GetWeakPtr(), scope, callback)));
 }
 
 ServiceWorkerRegistration* ServiceWorkerStorage::GetUninstallingRegistration(
     const GURL& scope) {
   if (state_ != INITIALIZED || !context_)
     return NULL;
   for (RegistrationRefsById::const_iterator it =
            uninstalling_registrations_.begin();
        it != uninstalling_registrations_.end();
        ++it) {
     if (it->second->pattern() == scope) {
       DCHECK(it->second->is_uninstalling());
-      return it->second;
+      return it->second.get();
     }
   }
   return NULL;
 }
 
 void ServiceWorkerStorage::FindRegistrationForId(
     int64 registration_id,
     const GURL& origin,
     const FindRegistrationCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForId,
           weak_factory_.GetWeakPtr(), registration_id, origin, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(scoped_refptr<ServiceWorkerRegistration>(),
                       SERVICE_WORKER_ERROR_FAILED, callback);
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   // See if there are any stored registrations for the origin.
   if (!ContainsKey(registered_origins_, origin)) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForId(registration_id);
-    CompleteFindNow(
-        installing_registration,
-        installing_registration ?
-            SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
-        callback);
+    CompleteFindNow(installing_registration,
+                    installing_registration.get()
+                        ? SERVICE_WORKER_OK
+                        : SERVICE_WORKER_ERROR_NOT_FOUND,
+                    callback);
     return;
   }
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(registration_id);
-  if (registration) {
+  if (registration.get()) {
     CompleteFindNow(registration, SERVICE_WORKER_OK, callback);
     return;
   }
 
   database_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FindForIdInDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  registration_id, origin,
                  base::Bind(&ServiceWorkerStorage::DidFindRegistrationForId,
                             weak_factory_.GetWeakPtr(), callback)));
 }
 
 void ServiceWorkerStorage::GetAllRegistrations(
     const GetAllRegistrationInfosCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::GetAllRegistrations,
           weak_factory_.GetWeakPtr(), callback))) {
     if (state_ != INITIALIZING || !context_) {
       RunSoon(FROM_HERE, base::Bind(
           callback, std::vector<ServiceWorkerRegistrationInfo>()));
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   RegistrationList* registrations = new RegistrationList;
   PostTaskAndReplyWithResult(
-      database_task_runner_,
+      database_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetAllRegistrations,
                  base::Unretained(database_.get()),
                  base::Unretained(registrations)),
       base::Bind(&ServiceWorkerStorage::DidGetAllRegistrations,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(registrations)));
 }
 
@@ skipping 43 matching lines @@
     const StatusCallback& callback) {
   DCHECK(registration);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   PostTaskAndReplyWithResult(
-      database_task_runner_,
+      database_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::UpdateVersionToActive,
                  base::Unretained(database_.get()),
                  registration->id(),
                  registration->script_url().GetOrigin()),
       base::Bind(&ServiceWorkerStorage::DidUpdateToActiveState,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
@@ skipping 98 matching lines @@
                            CreateResponseReader(rhs_id),
                            callback);
   comparer->Start();  // It deletes itself when done.
 }
 
 void ServiceWorkerStorage::DeleteAndStartOver(const StatusCallback& callback) {
   Disable();
 
   // Delete the database on the database thread.
   PostTaskAndReplyWithResult(
-      database_task_runner_,
+      database_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::DestroyDatabase,
                  base::Unretained(database_.get())),
       base::Bind(&ServiceWorkerStorage::DidDeleteDatabase,
-                 weak_factory_.GetWeakPtr(), callback));
+                 weak_factory_.GetWeakPtr(),
+                 callback));
 }
 
 int64 ServiceWorkerStorage::NewRegistrationId() {
   if (state_ == DISABLED)
     return kInvalidServiceWorkerRegistrationId;
   DCHECK_EQ(INITIALIZED, state_);
   return next_registration_id_++;
 }
 
 int64 ServiceWorkerStorage::NewVersionId() {
@@ skipping 164 matching lines @@
     ServiceWorkerDatabase::Status status) {
   if (status == ServiceWorkerDatabase::STATUS_OK) {
     ReturnFoundRegistration(callback, data, resources);
     return;
   }
 
   if (status == ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForDocument(document_url);
-    callback.Run(installing_registration ?
-        SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
-        installing_registration);
+    callback.Run(installing_registration.get() ? SERVICE_WORKER_OK
+                                               : SERVICE_WORKER_ERROR_NOT_FOUND,
+                 installing_registration);
     return;
   }
 
   ScheduleDeleteAndStartOver();
   callback.Run(DatabaseStatusToStatusCode(status),
                scoped_refptr<ServiceWorkerRegistration>());
 }
 
 void ServiceWorkerStorage::DidFindRegistrationForPattern(
     const GURL& scope,
     const FindRegistrationCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources,
     ServiceWorkerDatabase::Status status) {
   if (status == ServiceWorkerDatabase::STATUS_OK) {
     ReturnFoundRegistration(callback, data, resources);
     return;
   }
 
   if (status == ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForPattern(scope);
-    callback.Run(installing_registration ?
-        SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND,
-        installing_registration);
+    callback.Run(installing_registration.get() ? SERVICE_WORKER_OK
+                                               : SERVICE_WORKER_ERROR_NOT_FOUND,
+                 installing_registration);
     return;
   }
 
   ScheduleDeleteAndStartOver();
   callback.Run(DatabaseStatusToStatusCode(status),
                scoped_refptr<ServiceWorkerRegistration>());
 }
 
 void ServiceWorkerStorage::DidFindRegistrationForId(
     const FindRegistrationCallback& callback,
@@ skipping 143 matching lines @@
   if (!context_ || !context_->GetLiveVersion(version_id))
     StartPurgingResources(newly_purgeable_resources);
 }
 
 scoped_refptr<ServiceWorkerRegistration>
 ServiceWorkerStorage::GetOrCreateRegistration(
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources) {
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(data.registration_id);
-  if (registration)
+  if (registration.get())
     return registration;
 
   registration = new ServiceWorkerRegistration(
       data.scope, data.script, data.registration_id, context_);
   registration->set_last_update_check(data.last_update_check);
   if (pending_deletions_.find(data.registration_id) !=
       pending_deletions_.end()) {
     registration->set_is_deleted(true);
   }
   scoped_refptr<ServiceWorkerVersion> version =
       context_->GetLiveVersion(data.version_id);
-  if (!version) {
-    version = new ServiceWorkerVersion(registration, data.version_id, context_);
+  if (!version.get()) {
+    version =
+        new ServiceWorkerVersion(registration.get(), data.version_id, context_);
     version->SetStatus(data.is_active ?
         ServiceWorkerVersion::ACTIVATED : ServiceWorkerVersion::INSTALLED);
     version->script_cache_map()->SetResources(resources);
   }
 
   if (version->status() == ServiceWorkerVersion::ACTIVATED)
-    registration->SetActiveVersion(version);
+    registration->SetActiveVersion(version.get());
   else if (version->status() == ServiceWorkerVersion::INSTALLED)
-    registration->SetWaitingVersion(version);
+    registration->SetWaitingVersion(version.get());
   else
     NOTREACHED();
 
   return registration;
 }
 
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForDocument(
     const GURL& document_url) {
   DCHECK(!document_url.has_ref());
 
   LongestScopeMatcher matcher(document_url);
   ServiceWorkerRegistration* match = NULL;
 
   // TODO(nhiroki): This searches over installing registrations linearly and it
   // couldn't be scalable. Maybe the regs should be partitioned by origin.
   for (RegistrationRefsById::const_iterator it =
            installing_registrations_.begin();
        it != installing_registrations_.end(); ++it) {
     if (matcher.MatchLongest(it->second->pattern()))
-      match = it->second;
+      match = it->second.get();
   }
   return match;
 }
 
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForPattern(
     const GURL& scope) {
   for (RegistrationRefsById::const_iterator it =
            installing_registrations_.begin();
        it != installing_registrations_.end(); ++it) {
     if (it->second->pattern() == scope)
-      return it->second;
+      return it->second.get();
   }
   return NULL;
 }
 
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForId(
     int64 registration_id) {
   RegistrationRefsById::const_iterator found =
       installing_registrations_.find(registration_id);
   if (found == installing_registrations_.end())
     return NULL;
-  return found->second;
+  return found->second.get();
 }
 
 ServiceWorkerDiskCache* ServiceWorkerStorage::disk_cache() {
   if (disk_cache_)
     return disk_cache_.get();
 
   disk_cache_.reset(new ServiceWorkerDiskCache);
 
   base::FilePath path = GetDiskCachePath();
   if (path.empty()) {
@@ skipping 330 matching lines @@
     callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDatabase successfully.";
 
   // Delete the disk cache on the cache thread.
   // TODO(nhiroki): What if there is a bunch of files in the cache directory?
   // Deleting the directory could take a long time and restart could be delayed.
   // We should probably rename the directory and delete it later.
   PostTaskAndReplyWithResult(
-      database_task_runner_,
+      database_task_runner_.get(),
       FROM_HERE,
       base::Bind(&base::DeleteFile, GetDiskCachePath(), true),
       base::Bind(&ServiceWorkerStorage::DidDeleteDiskCache,
-                 weak_factory_.GetWeakPtr(), callback));
+                 weak_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void ServiceWorkerStorage::DidDeleteDiskCache(
     const StatusCallback& callback, bool result) {
   DCHECK_EQ(DISABLED, state_);
   if (!result) {
     // Give up the corruption recovery until the browser restarts.
     LOG(ERROR) << "Failed to delete the diskcache.";
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content