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

content/browser/background_sync/background_sync_service_impl_unittest.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_service_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 42 matching lines @@
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   *out_registration = registration;
 }
 
 // Callbacks from BackgroundSyncServiceImpl methods
 
 void ErrorAndRegistrationCallback(
     bool* called,
-    mojom::BackgroundSyncError* out_error,
-    mojom::SyncRegistrationPtr* out_registration,
-    mojom::BackgroundSyncError error,
-    const mojom::SyncRegistrationPtr& registration) {
+    blink::mojom::BackgroundSyncError* out_error,
+    blink::mojom::SyncRegistrationPtr* out_registration,
+    blink::mojom::BackgroundSyncError error,
+    const blink::mojom::SyncRegistrationPtr& registration) {
   *called = true;
   *out_error = error;
   *out_registration = registration.Clone();
 }
 
 void ErrorAndRegistrationListCallback(
     bool* called,
-    mojom::BackgroundSyncError* out_error,
+    blink::mojom::BackgroundSyncError* out_error,
     unsigned long* out_array_size,
-    mojom::BackgroundSyncError error,
-    mojo::Array<content::mojom::SyncRegistrationPtr> registrations) {
+    blink::mojom::BackgroundSyncError error,
+    mojo::Array<blink::mojom::SyncRegistrationPtr> registrations) {
   *called = true;
   *out_error = error;
-  if (error == mojom::BackgroundSyncError::NONE)
+  if (error == blink::mojom::BackgroundSyncError::NONE)
     *out_array_size = registrations.size();
 }
 
 }  // namespace
 
 class BackgroundSyncServiceImplTest : public testing::Test {
  public:
   BackgroundSyncServiceImplTest()
       : thread_bundle_(
             new TestBrowserThreadBundle(TestBrowserThreadBundle::IO_MAINLOOP)),
         network_change_notifier_(net::NetworkChangeNotifier::CreateMock()) {
-    default_sync_registration_ = mojom::SyncRegistration::New();
+    default_sync_registration_ = blink::mojom::SyncRegistration::New();
   }
 
   void SetUp() override {
     // Don't let the tests be confused by the real-world device connectivity
     background_sync_test_util::SetIgnoreNetworkChangeNotifier(true);
 
     CreateTestHelper();
     CreateStoragePartition();
     CreateBackgroundSyncContext();
     CreateServiceWorkerRegistration();
@@ skipping 70 matching lines @@
     embedded_worker_helper_->context_wrapper()->FindReadyRegistrationForId(
         sw_registration_id_, GURL(kServiceWorkerPattern).GetOrigin(),
         base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(sw_registration_);
   }
 
   void CreateBackgroundSyncServiceImpl() {
     // Create a dummy mojo channel so that the BackgroundSyncServiceImpl can be
     // instantiated.
-    mojo::InterfaceRequest<mojom::BackgroundSyncService> service_request =
-        mojo::GetProxy(&service_ptr_);
+    mojo::InterfaceRequest<blink::mojom::BackgroundSyncService>
+        service_request = mojo::GetProxy(&service_ptr_);
     // Create a new BackgroundSyncServiceImpl bound to the dummy channel.
     background_sync_context_->CreateService(std::move(service_request));
     base::RunLoop().RunUntilIdle();
 
     service_impl_ = *background_sync_context_->services_.begin();
     ASSERT_TRUE(service_impl_);
   }
 
   // Helpers for testing BackgroundSyncServiceImpl methods
   void Register(
-      mojom::SyncRegistrationPtr sync,
-      const mojom::BackgroundSyncService::RegisterCallback& callback) {
+      blink::mojom::SyncRegistrationPtr sync,
+      const blink::mojom::BackgroundSyncService::RegisterCallback& callback) {
     service_impl_->Register(std::move(sync), sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
   void GetRegistrations(
-      const mojom::BackgroundSyncService::GetRegistrationsCallback& callback) {
+      const blink::mojom::BackgroundSyncService::GetRegistrationsCallback&
+          callback) {
     service_impl_->GetRegistrations(sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
   std::unique_ptr<TestBrowserThreadBundle> thread_bundle_;
   std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   std::unique_ptr<EmbeddedWorkerTestHelper> embedded_worker_helper_;
   std::unique_ptr<StoragePartitionImpl> storage_partition_impl_;
   scoped_refptr<BackgroundSyncContext> background_sync_context_;
   int64_t sw_registration_id_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_;
-  mojom::BackgroundSyncServicePtr service_ptr_;
+  blink::mojom::BackgroundSyncServicePtr service_ptr_;
   BackgroundSyncServiceImpl*
       service_impl_;  // Owned by background_sync_context_
-  mojom::SyncRegistrationPtr default_sync_registration_;
+  blink::mojom::SyncRegistrationPtr default_sync_registration_;
 };
 
 // Tests
 
 TEST_F(BackgroundSyncServiceImplTest, Register) {
   bool called = false;
-  mojom::BackgroundSyncError error;
-  mojom::SyncRegistrationPtr reg;
+  blink::mojom::BackgroundSyncError error;
+  blink::mojom::SyncRegistrationPtr reg;
   Register(default_sync_registration_.Clone(),
            base::Bind(&ErrorAndRegistrationCallback, &called, &error, &reg));
   EXPECT_TRUE(called);
-  EXPECT_EQ(mojom::BackgroundSyncError::NONE, error);
+  EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, error);
   EXPECT_EQ("", reg->tag);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistrations) {
   bool called = false;
-  mojom::BackgroundSyncError error;
+  blink::mojom::BackgroundSyncError error;
   unsigned long array_size = 0UL;
   GetRegistrations(base::Bind(&ErrorAndRegistrationListCallback, &called,
                               &error, &array_size));
   EXPECT_TRUE(called);
-  EXPECT_EQ(mojom::BackgroundSyncError::NONE, error);
+  EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, error);
   EXPECT_EQ(0UL, array_size);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistrationsWithRegisteredSync) {
   bool register_called = false;
   bool getregistrations_called = false;
-  mojom::BackgroundSyncError register_error;
-  mojom::BackgroundSyncError getregistrations_error;
-  mojom::SyncRegistrationPtr register_reg;
+  blink::mojom::BackgroundSyncError register_error;
+  blink::mojom::BackgroundSyncError getregistrations_error;
+  blink::mojom::SyncRegistrationPtr register_reg;
   unsigned long array_size = 0UL;
   Register(default_sync_registration_.Clone(),
            base::Bind(&ErrorAndRegistrationCallback, &register_called,
                       &register_error, &register_reg));
   EXPECT_TRUE(register_called);
-  EXPECT_EQ(mojom::BackgroundSyncError::NONE, register_error);
+  EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, register_error);
   GetRegistrations(base::Bind(&ErrorAndRegistrationListCallback,
                               &getregistrations_called, &getregistrations_error,
                               &array_size));
   EXPECT_TRUE(getregistrations_called);
-  EXPECT_EQ(mojom::BackgroundSyncError::NONE, getregistrations_error);
+  EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, getregistrations_error);
   EXPECT_EQ(1UL, array_size);
 }
 
 }  // namespace content