[OnionSoup] Move background_sync.mojom from //content to //third_party/WebKit

content/child/background_sync/background_sync_provider.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/child/background_sync/background_sync_provider.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_local.h"
 #include "content/child/background_sync/background_sync_type_converters.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
-#include "content/public/common/background_sync.mojom.h"
 #include "third_party/WebKit/public/platform/modules/background_sync/WebSyncError.h"
 #include "third_party/WebKit/public/platform/modules/background_sync/WebSyncRegistration.h"
 
 using base::LazyInstance;
 using base::ThreadLocalPointer;
 
 namespace content {
 namespace {
 
 // Returns the id of the given |service_worker_registration|, which
 // is only available on the implementation of the interface.
 int64_t GetServiceWorkerRegistrationId(
     blink::WebServiceWorkerRegistration* service_worker_registration) {
   return static_cast<WebServiceWorkerRegistrationImpl*>(
              service_worker_registration)->registration_id();
 }
 
 void ConnectToServiceOnMainThread(
-    mojo::InterfaceRequest<mojom::BackgroundSyncService> request) {
+    mojo::InterfaceRequest<blink::mojom::BackgroundSyncService> request) {
   DCHECK(ChildThreadImpl::current());
   ChildThreadImpl::current()->service_registry()->ConnectToRemoteService(
       std::move(request));
 }
 
 LazyInstance<ThreadLocalPointer<BackgroundSyncProvider>>::Leaky
     g_sync_provider_tls = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
@@ skipping 12 matching lines @@
 BackgroundSyncProvider*
 BackgroundSyncProvider::GetOrCreateThreadSpecificInstance(
     base::SingleThreadTaskRunner* main_thread_task_runner) {
   DCHECK(main_thread_task_runner);
   if (g_sync_provider_tls.Pointer()->Get())
     return g_sync_provider_tls.Pointer()->Get();
 
   bool have_worker_id = (WorkerThread::GetCurrentId() > 0);
   if (!main_thread_task_runner->BelongsToCurrentThread() && !have_worker_id) {
     // On a worker thread, this could happen if this method is called
-    // very late (say by a garbage collected mojom::SyncRegistration).
+    // very late (say by a garbage collected blink::mojom::SyncRegistration).
     return nullptr;
   }
 
   BackgroundSyncProvider* instance =
       new BackgroundSyncProvider(main_thread_task_runner);
 
   if (have_worker_id) {
     // For worker threads, use the observer interface to clean up when workers
     // are stopped.
     WorkerThread::AddObserver(instance);
@@ skipping 10 matching lines @@
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   std::unique_ptr<const blink::WebSyncRegistration> optionsPtr(options);
   std::unique_ptr<blink::WebSyncRegistrationCallbacks> callbacksPtr(callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->Register(
-      mojo::ConvertTo<mojom::SyncRegistrationPtr>(*(optionsPtr.get())),
+      mojo::ConvertTo<blink::mojom::SyncRegistrationPtr>(*(optionsPtr.get())),
       service_worker_registration_id,
       base::Bind(&BackgroundSyncProvider::RegisterCallback,
                  base::Unretained(this),
                  base::Passed(std::move(callbacksPtr))));
 }
 
 void BackgroundSyncProvider::getRegistrations(
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebSyncGetRegistrationsCallbacks* callbacks) {
   DCHECK(service_worker_registration);
@@ skipping 11 matching lines @@
                  base::Unretained(this),
                  base::Passed(std::move(callbacksPtr))));
 }
 
 void BackgroundSyncProvider::WillStopCurrentWorkerThread() {
   delete this;
 }
 
 void BackgroundSyncProvider::RegisterCallback(
     std::unique_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
-    mojom::BackgroundSyncError error,
-    const mojom::SyncRegistrationPtr& options) {
+    blink::mojom::BackgroundSyncError error,
+    const blink::mojom::SyncRegistrationPtr& options) {
   // TODO(iclelland): Determine the correct error message to return in each case
   std::unique_ptr<blink::WebSyncRegistration> result;
   switch (error) {
-    case mojom::BackgroundSyncError::NONE:
+    case blink::mojom::BackgroundSyncError::NONE:
       if (!options.is_null())
         result = mojo::ConvertTo<std::unique_ptr<blink::WebSyncRegistration>>(
             options);
       callbacks->onSuccess(std::move(result));
       break;
-    case mojom::BackgroundSyncError::NOT_FOUND:
+    case blink::mojom::BackgroundSyncError::NOT_FOUND:
       NOTREACHED();
       break;
-    case mojom::BackgroundSyncError::STORAGE:
+    case blink::mojom::BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case mojom::BackgroundSyncError::NOT_ALLOWED:
+    case blink::mojom::BackgroundSyncError::NOT_ALLOWED:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeNoPermission,
                               "Attempted to register a sync event without a "
                               "window or registration tag too long."));
       break;
-    case mojom::BackgroundSyncError::PERMISSION_DENIED:
+    case blink::mojom::BackgroundSyncError::PERMISSION_DENIED:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypePermissionDenied,
                               "Permission denied."));
       break;
-    case mojom::BackgroundSyncError::NO_SERVICE_WORKER:
+    case blink::mojom::BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::GetRegistrationsCallback(
     std::unique_ptr<blink::WebSyncGetRegistrationsCallbacks> callbacks,
-    mojom::BackgroundSyncError error,
-    const mojo::Array<mojom::SyncRegistrationPtr>& registrations) {
+    blink::mojom::BackgroundSyncError error,
+    const mojo::Array<blink::mojom::SyncRegistrationPtr>& registrations) {
   // TODO(iclelland): Determine the correct error message to return in each case
   switch (error) {
-    case mojom::BackgroundSyncError::NONE: {
+    case blink::mojom::BackgroundSyncError::NONE: {
       blink::WebVector<blink::WebSyncRegistration*> results(
           registrations.size());
       for (size_t i = 0; i < registrations.size(); ++i) {
         results[i] =
             mojo::ConvertTo<std::unique_ptr<blink::WebSyncRegistration>>(
                 registrations[i])
                 .release();
       }
       callbacks->onSuccess(results);
       break;
     }
-    case mojom::BackgroundSyncError::NOT_FOUND:
-    case mojom::BackgroundSyncError::NOT_ALLOWED:
-    case mojom::BackgroundSyncError::PERMISSION_DENIED:
+    case blink::mojom::BackgroundSyncError::NOT_FOUND:
+    case blink::mojom::BackgroundSyncError::NOT_ALLOWED:
+    case blink::mojom::BackgroundSyncError::PERMISSION_DENIED:
       // These errors should never be returned from
       // BackgroundSyncManager::GetRegistrations
       NOTREACHED();
       break;
-    case mojom::BackgroundSyncError::STORAGE:
+    case blink::mojom::BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case mojom::BackgroundSyncError::NO_SERVICE_WORKER:
+    case blink::mojom::BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
-mojom::BackgroundSyncServicePtr&
+blink::mojom::BackgroundSyncServicePtr&
 BackgroundSyncProvider::GetBackgroundSyncServicePtr() {
   if (!background_sync_service_.get()) {
-    mojo::InterfaceRequest<mojom::BackgroundSyncService> request =
+    mojo::InterfaceRequest<blink::mojom::BackgroundSyncService> request =
         mojo::GetProxy(&background_sync_service_);
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ConnectToServiceOnMainThread, base::Passed(&request)));
   }
   return background_sync_service_;
 }
 
 }  // namespace content