[Background Sync] Use GcmNetworkManager to start the browser for sync events.

content/browser/background_sync/background_sync_manager.cc

 // Copyright 2015 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/background_sync/background_sync_manager.h"
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/metrics/field_trial.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/background_sync/background_sync_metrics.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/background_sync/background_sync_power_observer.h"
 #include "content/browser/background_sync/background_sync_registration_handle.h"
 #include "content/browser/background_sync/background_sync_registration_options.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/public/browser/background_sync_controller.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_ANDROID)
-#include "content/browser/android/background_sync_launcher_android.h"
 #include "content/browser/android/background_sync_network_observer_android.h"
 #endif
 
 namespace content {
 
 class BackgroundSyncManager::RefCountedRegistration
     : public base::RefCounted<RefCountedRegistration> {
  public:
   BackgroundSyncRegistration* value() { return &registration_; }
   const BackgroundSyncRegistration* value() const { return &registration_; }
@@ skipping 18 matching lines @@
           callback, status,
           base::Passed(scoped_ptr<BackgroundSyncRegistrationHandle>().Pass())));
 }
 
 bool ShouldDisableForFieldTrial() {
   std::string experiment = base::FieldTrialList::FindFullName("BackgroundSync");
   return base::StartsWith(experiment, "ExperimentDisable",
                           base::CompareCase::INSENSITIVE_ASCII);
 }
 
+// Returns nullptr if the controller cannot be accessed for any reason.
+BackgroundSyncController* GetBackgroundSyncControllerOnUIThread(
+    const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (!service_worker_context)
+    return nullptr;
+  StoragePartitionImpl* storage_partition_impl =
+      service_worker_context->storage_partition();
+  if (!storage_partition_impl)  // may be null in tests
+    return nullptr;
+
+  return storage_partition_impl->browser_context()
+      ->GetBackgroundSyncController();
+}
+
 void NotifyBackgroundSyncRegisteredOnUIThread(
     const scoped_refptr<ServiceWorkerContextWrapper>& sw_context_wrapper,
     const GURL& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  StoragePartitionImpl* storage_partition_impl =
-      sw_context_wrapper->storage_partition();
-  if (!storage_partition_impl)  // happens in tests
-    return;
-
   BackgroundSyncController* background_sync_controller =
-      storage_partition_impl->browser_context()->GetBackgroundSyncController();
+      GetBackgroundSyncControllerOnUIThread(sw_context_wrapper);
 
   if (!background_sync_controller)
     return;
 
   background_sync_controller->NotifyBackgroundSyncRegistered(origin);
 }
 
 }  // namespace
 
 BackgroundSyncManager::BackgroundSyncRegistrations::
@@ skipping 888 matching lines @@
         if (registration.options()->periodicity == SYNC_ONE_SHOT) {
           keep_browser_alive_for_one_shot = true;
         } else {
           // TODO(jkarlin): Support keeping the browser alive for periodic
           // syncs.
         }
       }
     }
   }
 
-  // TODO(jkarlin): Use the context's path instead of the 'this' pointer as an
-  // identifier. See crbug.com/489705.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&BackgroundSyncLauncherAndroid::LaunchBrowserWhenNextOnline,
-                 this, keep_browser_alive_for_one_shot));
+      base::Bind(&BackgroundSyncManager::SchedulePendingRegistrationsOnUIThread,
+                 base::Unretained(this), keep_browser_alive_for_one_shot));
+
 #else
 // TODO(jkarlin): Toggle Chrome's background mode.
 #endif
 }
 
+void BackgroundSyncManager::SchedulePendingRegistrationsOnUIThread(
+    bool keep_browser_alive_for_one_shot) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  BackgroundSyncController* background_sync_controller =
+      GetBackgroundSyncControllerOnUIThread(service_worker_context_);
+  if (background_sync_controller) {
+    // TODO(jkarlin): Use the context's path instead of the 'this' pointer as an
+    // identifier. See crbug.com/489705.
+    background_sync_controller->LaunchBrowserWhenNextOnline(
+        this, keep_browser_alive_for_one_shot);
+  }
+}
+
 void BackgroundSyncManager::FireReadyEvents() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_)
     return;
 
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::FireReadyEventsImpl,
                  weak_ptr_factory_.GetWeakPtr(), MakeEmptyCompletion()));
 }
@@ skipping 313 matching lines @@
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return base::Bind(
       &BackgroundSyncManager::CompleteOperationCallback<StatusCallback,
                                                         BackgroundSyncStatus>,
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content