ServiceWorker: Decompose SWRegistration::SetVersionInternal for readability

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 66 matching lines @@
   return ServiceWorkerRegistrationInfo(
       pattern(), registration_id_,
       is_deleted_ ? ServiceWorkerRegistrationInfo::IS_DELETED
                   : ServiceWorkerRegistrationInfo::IS_NOT_DELETED,
       GetVersionInfo(active_version_.get()),
       GetVersionInfo(waiting_version_.get()),
       GetVersionInfo(installing_version_.get()), resources_total_size_bytes_);
 }
 
 void ServiceWorkerRegistration::SetActiveVersion(
-    ServiceWorkerVersion* version) {
+    const scoped_refptr<ServiceWorkerVersion>& version) {
   should_activate_when_ready_ = false;
-  SetVersionInternal(version, &active_version_,
-                     ChangedVersionAttributesMask::ACTIVE_VERSION);
+  if (active_version_ == version)
+    return;
+
+  ChangedVersionAttributesMask mask;
+  if (version)
+    UnsetVersionInternal(version.get(), &mask);
+  if (active_version_)
+    active_version_->RemoveListener(this);
+  active_version_ = version;
+  if (active_version_)
+    active_version_->AddListener(this);
+  mask.add(ChangedVersionAttributesMask::ACTIVE_VERSION);
+
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnVersionAttributesChanged(this, mask, GetInfo()));
 }
 
 void ServiceWorkerRegistration::SetWaitingVersion(
-    ServiceWorkerVersion* version) {
+    const scoped_refptr<ServiceWorkerVersion>& version) {
   should_activate_when_ready_ = false;
-  SetVersionInternal(version, &waiting_version_,
-                     ChangedVersionAttributesMask::WAITING_VERSION);
+  if (waiting_version_ == version)
+    return;
+
+  ChangedVersionAttributesMask mask;
+  if (version)
+    UnsetVersionInternal(version.get(), &mask);
+  waiting_version_ = version;
+  mask.add(ChangedVersionAttributesMask::WAITING_VERSION);
+
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnVersionAttributesChanged(this, mask, GetInfo()));
 }
 
 void ServiceWorkerRegistration::SetInstallingVersion(
-    ServiceWorkerVersion* version) {
-  SetVersionInternal(version, &installing_version_,
-                     ChangedVersionAttributesMask::INSTALLING_VERSION);
+    const scoped_refptr<ServiceWorkerVersion>& version) {
+  if (installing_version_ == version)
+    return;
+
+  ChangedVersionAttributesMask mask;
+  if (version)
+    UnsetVersionInternal(version.get(), &mask);
+  installing_version_ = version;
+  mask.add(ChangedVersionAttributesMask::INSTALLING_VERSION);
+
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnVersionAttributesChanged(this, mask, GetInfo()));
 }
 
 void ServiceWorkerRegistration::UnsetVersion(ServiceWorkerVersion* version) {
   if (!version)
     return;
   ChangedVersionAttributesMask mask;
   UnsetVersionInternal(version, &mask);
   if (mask.changed()) {
     ServiceWorkerRegistrationInfo info = GetInfo();
     FOR_EACH_OBSERVER(Listener, listeners_,
                       OnVersionAttributesChanged(this, mask, info));
   }
 }
 
-void ServiceWorkerRegistration::SetVersionInternal(
-    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);
-  if (*data_member && *data_member == active_version_)
-    active_version_->RemoveListener(this);
-  *data_member = 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_.get() == version) {
     installing_version_ = NULL;
     mask->add(ChangedVersionAttributesMask::INSTALLING_VERSION);
   } else if (waiting_version_.get() == version) {
     waiting_version_ = NULL;
     mask->add(ChangedVersionAttributesMask::WAITING_VERSION);
@@ skipping 122 matching lines @@
     // "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);
   }
 
   // "6. Set serviceWorkerRegistration.activeWorker to activatingWorker."
   // "7. Set serviceWorkerRegistration.waitingWorker to null."
-  SetActiveVersion(activating_version.get());
+  SetActiveVersion(activating_version);
 
   // "8. Run the [[UpdateState]] algorithm passing registration.activeWorker and
   // "activating" as arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATING);
   // "9. Fire a simple event named controllerchange..."
   if (activating_version->skip_waiting())
     FOR_EACH_OBSERVER(Listener, listeners_, OnSkippedWaiting(this));
 
   // "10. Queue a task to fire an event named activate..."
   activating_version->DispatchActivateEvent(
@@ skipping 99 matching lines @@
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
   context_->storage()->NotifyDoneInstallingRegistration(
       this, version.get(), status);
   callback.Run(status);
 }
 
 }  // namespace content