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

content/browser/service_worker/service_worker_registration.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_registration.h"
 
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_register_job.h"
 #include "content/browser/service_worker/service_worker_utils.h"
@@ skipping 48 matching lines @@
 void ServiceWorkerRegistration::NotifyRegistrationFailed() {
   FOR_EACH_OBSERVER(Listener, listeners_, OnRegistrationFailed(this));
 }
 
 ServiceWorkerRegistrationInfo ServiceWorkerRegistration::GetInfo() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return ServiceWorkerRegistrationInfo(
       script_url(),
       pattern(),
       registration_id_,
-      GetVersionInfo(active_version_),
-      GetVersionInfo(waiting_version_),
-      GetVersionInfo(installing_version_));
+      GetVersionInfo(active_version_.get()),
+      GetVersionInfo(waiting_version_.get()),
+      GetVersionInfo(installing_version_.get()));
 }
 
 void ServiceWorkerRegistration::SetActiveVersion(
     ServiceWorkerVersion* version) {
   should_activate_when_ready_ = false;
   SetVersionInternal(version, &active_version_,
                      ChangedVersionAttributesMask::ACTIVE_VERSION);
 }
 
 void ServiceWorkerRegistration::SetWaitingVersion(
@@ skipping 25 matching lines @@
     ServiceWorkerVersion* version,
     scoped_refptr<ServiceWorkerVersion>* data_member,
     int change_flag) {
   if (version == data_member->get())
     return;
   scoped_refptr<ServiceWorkerVersion> protect(version);
   ChangedVersionAttributesMask mask;
   if (version)
     UnsetVersionInternal(version, &mask);
   *data_member = version;
-  if (active_version_ && active_version_ == version)
+  if (active_version_.get() && active_version_.get() == version)
     active_version_->AddListener(this);
   mask.add(change_flag);
   ServiceWorkerRegistrationInfo info = GetInfo();
   FOR_EACH_OBSERVER(Listener, listeners_,
                     OnVersionAttributesChanged(this, mask, info));
 }
 
 void ServiceWorkerRegistration::UnsetVersionInternal(
     ServiceWorkerVersion* version,
     ChangedVersionAttributesMask* mask) {
   DCHECK(version);
-  if (installing_version_ == version) {
+  if (installing_version_.get() == version) {
     installing_version_ = NULL;
     mask->add(ChangedVersionAttributesMask::INSTALLING_VERSION);
-  } else if (waiting_version_  == version) {
+  } else if (waiting_version_.get() == version) {
     waiting_version_ = NULL;
     mask->add(ChangedVersionAttributesMask::WAITING_VERSION);
-  } else if (active_version_ == version) {
+  } else if (active_version_.get() == version) {
     active_version_->RemoveListener(this);
     active_version_ = NULL;
     mask->add(ChangedVersionAttributesMask::ACTIVE_VERSION);
   }
 }
 
 void ServiceWorkerRegistration::ActivateWaitingVersionWhenReady() {
   DCHECK(waiting_version());
   should_activate_when_ready_ = true;
   if (!active_version() || !active_version()->HasControllee())
@@ skipping 18 matching lines @@
 
 void ServiceWorkerRegistration::AbortPendingClear() {
   DCHECK(context_);
   if (!is_uninstalling())
     return;
   is_uninstalling_ = false;
   context_->storage()->NotifyDoneUninstallingRegistration(this);
 
   scoped_refptr<ServiceWorkerVersion> most_recent_version =
       waiting_version() ? waiting_version() : active_version();
-  DCHECK(most_recent_version);
+  DCHECK(most_recent_version.get());
   context_->storage()->NotifyInstallingRegistration(this);
   context_->storage()->StoreRegistration(
       this,
-      most_recent_version,
+      most_recent_version.get(),
       base::Bind(&ServiceWorkerRegistration::OnStoreFinished,
                  this,
                  most_recent_version));
 }
 
 void ServiceWorkerRegistration::OnNoControllees(ServiceWorkerVersion* version) {
   DCHECK_EQ(active_version(), version);
   if (is_uninstalling_)
     Clear();
   else if (should_activate_when_ready_)
     ActivateWaitingVersion();
   is_uninstalling_ = false;
   should_activate_when_ready_ = false;
 }
 
 void ServiceWorkerRegistration::ActivateWaitingVersion() {
   DCHECK(context_);
   DCHECK(waiting_version());
   DCHECK(should_activate_when_ready_);
   should_activate_when_ready_ = false;
   scoped_refptr<ServiceWorkerVersion> activating_version = waiting_version();
   scoped_refptr<ServiceWorkerVersion> exiting_version = active_version();
 
   if (activating_version->is_doomed() ||
       activating_version->status() == ServiceWorkerVersion::REDUNDANT) {
     return;  // Activation is no longer relevant.
   }
 
   // "4. If exitingWorker is not null,
-  if (exiting_version) {
+  if (exiting_version.get()) {
     DCHECK(!exiting_version->HasControllee());
     // TODO(michaeln): should wait for events to be complete
     // "1. Wait for exitingWorker to finish handling any in-progress requests."
     // "2. Terminate exitingWorker."
     exiting_version->StopWorker(
         base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
     // "3. Run the [[UpdateState]] algorithm passing exitingWorker and
     // "redundant" as the arguments."
     exiting_version->SetStatus(ServiceWorkerVersion::REDUNDANT);
   }
 
   // "5. Set serviceWorkerRegistration.activeWorker to activatingWorker."
   // "6. Set serviceWorkerRegistration.waitingWorker to null."
-  SetActiveVersion(activating_version);
+  SetActiveVersion(activating_version.get());
 
   // "7. Run the [[UpdateState]] algorithm passing registration.activeWorker and
   // "activating" as arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATING);
 
   // TODO(nhiroki): "8. Fire a simple event named controllerchange..."
 
   // "9. Queue a task to fire an event named activate..."
   activating_version->DispatchActivateEvent(
       base::Bind(&ServiceWorkerRegistration::OnActivateEventFinished,
@@ skipping 36 matching lines @@
 void ServiceWorkerRegistration::OnDeleteFinished(
     ServiceWorkerStatusCode status) {
   // Intentionally empty completion callback, used to prevent
   // |this| from being deleted until the storage method completes.
 }
 
 void ServiceWorkerRegistration::Clear() {
   context_->storage()->NotifyDoneUninstallingRegistration(this);
 
   ChangedVersionAttributesMask mask;
-  if (installing_version_) {
+  if (installing_version_.get()) {
     installing_version_->Doom();
     installing_version_ = NULL;
     mask.add(ChangedVersionAttributesMask::INSTALLING_VERSION);
   }
-  if (waiting_version_) {
+  if (waiting_version_.get()) {
     waiting_version_->Doom();
     waiting_version_ = NULL;
     mask.add(ChangedVersionAttributesMask::WAITING_VERSION);
   }
-  if (active_version_) {
+  if (active_version_.get()) {
     active_version_->Doom();
     active_version_->RemoveListener(this);
     active_version_ = NULL;
     mask.add(ChangedVersionAttributesMask::ACTIVE_VERSION);
   }
   if (mask.changed()) {
     ServiceWorkerRegistrationInfo info = GetInfo();
     FOR_EACH_OBSERVER(Listener, listeners_,
                       OnVersionAttributesChanged(this, mask, info));
   }
 }
 
 void ServiceWorkerRegistration::OnStoreFinished(
     scoped_refptr<ServiceWorkerVersion> version,
     ServiceWorkerStatusCode status) {
   if (!context_)
     return;
   context_->storage()->NotifyDoneInstallingRegistration(
       this, version.get(), status);
 }
 
 }  // namespace content