Move content/child/background_sync to Blink.

third_party/WebKit/Source/modules/background_sync/SyncManager.cpp

 // 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 "modules/background_sync/SyncManager.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/background_sync/SyncCallbacks.h"
 #include "modules/serviceworkers/ServiceWorkerRegistration.h"
 #include "public/platform/Platform.h"
-#include "public/platform/modules/background_sync/WebSyncProvider.h"
-#include "public/platform/modules/background_sync/WebSyncRegistration.h"
-#include "wtf/RefPtr.h"
+#include "wtf/ThreadSpecific.h"
 
 namespace blink {
-namespace {
 
-WebSyncProvider* backgroundSyncProvider() {
-  WebSyncProvider* webSyncProvider =
-      Platform::current()->backgroundSyncProvider();
-  ASSERT(webSyncProvider);
-  return webSyncProvider;
-}
+// static
+BackgroundSyncProvider* SyncManager::backgroundSyncProvider() {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<BackgroundSyncProvider>,
+                                  sync_provider,

[jbroman, 2016/11/05 22:51:09]

nit: no underscores in variable names in Blink (for m_, s_, etc. prefixes)
https://www.chromium.org/blink/coding-style#TOC-Names

Going back and forth between Blink and the rest of Chromium, this can be
annoying to keep straight. People are working on making this consistent in the
future.

[adithyas, 2016/11/07 19:22:55]

Done.

+                                  new ThreadSpecific<BackgroundSyncProvider>);

[haraken, 2016/11/05 13:00:19]

Is there any per-worker object with which BackgroundSyncProvider should be
associated? In general, we want to avoid using ThreadSpecific to store
per-worker things.

[jbroman, 2016/11/05 22:51:09]

My two cents: a thread-specific object is how this currently works, so it might
be worth maintaining that to avoid mixing too many changes into this one CL.

Ultimately, it looks to me (iclelland might know better) that this class can
ultimately be merged into SyncManager, which has a more typical lifetime (it's a
garbage-collected supplement to the ServiceWorkerRegistration).

+  DCHECK(sync_provider);
+  return sync_provider;
 }
 
 SyncManager::SyncManager(ServiceWorkerRegistration* registration)
     : m_registration(registration) {
-  ASSERT(registration);
+  DCHECK(registration);
 }
 
 ScriptPromise SyncManager::registerFunction(ScriptState* scriptState,
                                             ExecutionContext* context,
                                             const String& tag) {
   // TODO(jkarlin): Wait for the registration to become active instead of
   // rejecting. See crbug.com/542437.
   if (!m_registration->active())
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(AbortError,
                              "Registration failed - no active Service Worker"));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
-  WebSyncRegistration* webSyncRegistration = new WebSyncRegistration(
-      WebSyncRegistration::UNREGISTERED_SYNC_ID /* id */, tag,
-      WebSyncRegistration::NetworkStateOnline /* networkState */
-      );
+  mojom::blink::SyncRegistrationPtr syncRegistration =
+      mojom::blink::SyncRegistration::New();
+  syncRegistration->id = SyncManager::UNREGISTERED_SYNC_ID;
+  syncRegistration->tag = tag;
+  syncRegistration->network_state =
+      blink::mojom::BackgroundSyncNetworkState::ONLINE;
+
   backgroundSyncProvider()->registerBackgroundSync(
-      webSyncRegistration, m_registration->webRegistration(),
+      syncRegistration, m_registration->webRegistration(),
       new SyncRegistrationCallbacks(resolver, m_registration));
 
   return promise;
 }
 
 ScriptPromise SyncManager::getTags(ScriptState* scriptState) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   backgroundSyncProvider()->getRegistrations(
       m_registration->webRegistration(),
       new SyncGetRegistrationsCallbacks(resolver, m_registration));
 
   return promise;
 }
 
 DEFINE_TRACE(SyncManager) {
   visitor->trace(m_registration);
 }
 
 }  // namespace blink