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

content/browser/service_worker/service_worker_register_job.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_register_job.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 68 matching lines @@
         &ServiceWorkerRegisterJob::ContinueWithRegistration,
         weak_factory_.GetWeakPtr());
   } else {
     next_step = base::Bind(
         &ServiceWorkerRegisterJob::ContinueWithUpdate,
         weak_factory_.GetWeakPtr());
   }
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->storage()->GetUninstallingRegistration(pattern_);
-  if (registration)
+  if (registration.get())
     RunSoon(base::Bind(next_step, SERVICE_WORKER_OK, registration));
   else
     context_->storage()->FindRegistrationForPattern(pattern_, next_step);
 }
 
 void ServiceWorkerRegisterJob::Abort() {
   SetPhase(ABORT);
   CompleteInternal(SERVICE_WORKER_ERROR_ABORT);
   // Don't have to call FinishJob() because the caller takes care of removing
   // the jobs from the queue.
@@ skipping 12 matching lines @@
   return job_type_;
 }
 
 ServiceWorkerRegisterJob::Internal::Internal() {}
 
 ServiceWorkerRegisterJob::Internal::~Internal() {}
 
 void ServiceWorkerRegisterJob::set_registration(
     ServiceWorkerRegistration* registration) {
   DCHECK(phase_ == START || phase_ == REGISTER) << phase_;
-  DCHECK(!internal_.registration);
+  DCHECK(!internal_.registration.get());
   internal_.registration = registration;
 }
 
 ServiceWorkerRegistration* ServiceWorkerRegisterJob::registration() {
   DCHECK(phase_ >= REGISTER || job_type_ == UPDATE_JOB) << phase_;
-  return internal_.registration;
+  return internal_.registration.get();
 }
 
 void ServiceWorkerRegisterJob::set_new_version(
     ServiceWorkerVersion* version) {
   DCHECK(phase_ == UPDATE) << phase_;
-  DCHECK(!internal_.new_version);
+  DCHECK(!internal_.new_version.get());
   internal_.new_version = version;
 }
 
 ServiceWorkerVersion* ServiceWorkerRegisterJob::new_version() {
   DCHECK(phase_ >= UPDATE) << phase_;
-  return internal_.new_version;
+  return internal_.new_version.get();
 }
 
 void ServiceWorkerRegisterJob::SetPhase(Phase phase) {
   switch (phase) {
     case INITIAL:
       NOTREACHED();
       break;
     case START:
       DCHECK(phase_ == INITIAL) << phase_;
       break;
@@ skipping 23 matching lines @@
 // Throughout this file, comments in quotes are excerpts from the spec.
 void ServiceWorkerRegisterJob::ContinueWithRegistration(
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& existing_registration) {
   DCHECK_EQ(REGISTRATION_JOB, job_type_);
   if (status != SERVICE_WORKER_ERROR_NOT_FOUND && status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
   }
 
-  if (!existing_registration) {
+  if (!existing_registration.get()) {
     RegisterAndContinue(SERVICE_WORKER_OK);
     return;
   }
 
   // "Set registration.[[Uninstalling]] to false."
   existing_registration->AbortPendingClear();
 
   // "If scriptURL is equal to registration.[[ScriptURL]], then:"
   if (existing_registration->script_url() == script_url_) {
     // Spec says to resolve with registration.[[GetNewestWorker]]. We come close
     // by resolving with the active version.
-    set_registration(existing_registration);
+    set_registration(existing_registration.get());
 
     if (!existing_registration->active_version()) {
       UpdateAndContinue();
       return;
     }
 
-    ResolvePromise(
-        status, existing_registration, existing_registration->active_version());
+    ResolvePromise(status,
+                   existing_registration.get(),
+                   existing_registration->active_version());
     Complete(SERVICE_WORKER_OK);
     return;
   }
 
   // "Set registration.[[ScriptURL]] to scriptURL." We accomplish this by
   // deleting the existing registration and registering a new one.
   // TODO(michaeln): Deactivate the live existing_registration object and
   // eventually call storage->DeleteVersionResources() when it no longer has any
   // controllees.
   context_->storage()->DeleteRegistration(
       existing_registration->id(),
       existing_registration->script_url().GetOrigin(),
       base::Bind(&ServiceWorkerRegisterJob::RegisterAndContinue,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerRegisterJob::ContinueWithUpdate(
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& existing_registration) {
   DCHECK_EQ(UPDATE_JOB, job_type_);
   if (status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
   }
 
-  if (existing_registration != registration()) {
+  if (existing_registration.get() != registration()) {
     Complete(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
 
   // TODO(michaeln): If the last update check was less than 24 hours
   // ago, depending on the freshness of the cached worker script we
   // may be able to complete the update job right here.
 
   UpdateAndContinue();
 }
@@ skipping 177 matching lines @@
   }
   callbacks_.clear();
 }
 
 void ServiceWorkerRegisterJob::OnPausedAfterDownload() {
   // This happens prior to OnStartWorkerFinished time.
   scoped_refptr<ServiceWorkerVersion> most_recent_version =
       registration()->waiting_version() ?
           registration()->waiting_version() :
           registration()->active_version();
-  DCHECK(most_recent_version);
+  DCHECK(most_recent_version.get());
   int64 most_recent_script_id =
       most_recent_version->script_cache_map()->Lookup(script_url_);
   int64 new_script_id =
       new_version()->script_cache_map()->Lookup(script_url_);
 
   // TODO(michaeln): It would be better to compare as the new resource
   // is being downloaded and to avoid writing it to disk until we know
   // its needed.
   context_->storage()->CompareScriptResources(
       most_recent_script_id, new_script_id,
@@ skipping 38 matching lines @@
     ServiceWorkerProviderHost* host = it->GetProviderHost();
     if (ServiceWorkerUtils::ScopeMatches(registration->pattern(),
                                          host->document_url())) {
       if (host->CanAssociateRegistration(registration))
         host->AssociateRegistration(registration);
     }
   }
 }
 
 }  // namespace content