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

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 <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "build/build_config.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_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/common/service_worker/service_worker_type_converters.h"
 #include "content/public/browser/background_sync_controller.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
-#include "content/public/common/background_sync.mojom.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/android/background_sync_network_observer_android.h"
 #endif
 
 namespace content {
 
 namespace {
 
 // The key used to index the background sync data in ServiceWorkerStorage.
@@ skipping 103 matching lines @@
   }
 
   background_sync_controller->GetParameterOverrides(parameters.get());
   return parameters;
 }
 
 void OnSyncEventFinished(
     const scoped_refptr<ServiceWorkerVersion>& active_version,
     int request_id,
     const ServiceWorkerVersion::StatusCallback& callback,
-    mojom::ServiceWorkerEventStatus status) {
+    blink::mojom::ServiceWorkerEventStatus status) {
   if (!active_version->FinishRequest(
           request_id,
-          status == content::mojom::ServiceWorkerEventStatus::COMPLETED)) {
+          status == blink::mojom::ServiceWorkerEventStatus::COMPLETED)) {
     return;
   }
   callback.Run(mojo::ConvertTo<ServiceWorkerStatusCode>(status));
 }
 
 }  // namespace
 
 BackgroundSyncManager::BackgroundSyncRegistrations::
     BackgroundSyncRegistrations()
     : next_id(BackgroundSyncRegistration::kInitialId) {
@@ skipping 331 matching lines @@
     BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
         AreOptionConditionsMet(options)
             ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
             : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
     BackgroundSyncMetrics::CountRegisterSuccess(
         registration_could_fire,
         BackgroundSyncMetrics::REGISTRATION_IS_DUPLICATE);
 
     if (existing_registration->IsFiring()) {
       existing_registration->set_sync_state(
-          mojom::BackgroundSyncState::REREGISTERED_WHILE_FIRING);
+          blink::mojom::BackgroundSyncState::REREGISTERED_WHILE_FIRING);
     }
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
                    base::Passed(base::WrapUnique(new BackgroundSyncRegistration(
                        *existing_registration)))));
     return;
   }
 
@@ skipping 212 matching lines @@
         callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->GetUserDataForAllRegistrations(backend_key,
                                                           callback);
 }
 
 void BackgroundSyncManager::DispatchSyncEvent(
     const std::string& tag,
     const scoped_refptr<ServiceWorkerVersion>& active_version,
-    mojom::BackgroundSyncEventLastChance last_chance,
+    blink::mojom::BackgroundSyncEventLastChance last_chance,
     const ServiceWorkerVersion::StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(active_version);
 
   if (active_version->running_status() != ServiceWorkerVersion::RUNNING) {
     active_version->RunAfterStartWorker(
         ServiceWorkerMetrics::EventType::SYNC,
         base::Bind(&BackgroundSyncManager::DispatchSyncEvent,
                    weak_ptr_factory_.GetWeakPtr(), tag, active_version,
                    last_chance, callback),
         callback);
     return;
   }
 
   int request_id = active_version->StartRequestWithCustomTimeout(
       ServiceWorkerMetrics::EventType::SYNC, callback,
       parameters_->max_sync_event_duration,
       ServiceWorkerVersion::CONTINUE_ON_TIMEOUT);
-  base::WeakPtr<mojom::BackgroundSyncServiceClient> client =
+  base::WeakPtr<blink::mojom::BackgroundSyncServiceClient> client =
       active_version
-          ->GetMojoServiceForRequest<mojom::BackgroundSyncServiceClient>(
+          ->GetMojoServiceForRequest<blink::mojom::BackgroundSyncServiceClient>(
               request_id);
 
   client->Sync(
       tag, last_chance,
       base::Bind(&OnSyncEventFinished, active_version, request_id, callback));
 }
 
 void BackgroundSyncManager::ScheduleDelayedTask(const base::Closure& callback,
                                                 base::TimeDelta delay) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, callback,
@@ skipping 43 matching lines @@
 bool BackgroundSyncManager::AreOptionConditionsMet(
     const BackgroundSyncRegistrationOptions& options) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return network_observer_->NetworkSufficient(options.network_state);
 }
 
 bool BackgroundSyncManager::IsRegistrationReadyToFire(
     const BackgroundSyncRegistration& registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (registration.sync_state() != mojom::BackgroundSyncState::PENDING)
+  if (registration.sync_state() != blink::mojom::BackgroundSyncState::PENDING)
     return false;
 
   if (clock_->Now() < registration.delay_until())
     return false;
 
   return AreOptionConditionsMet(*registration.options());
 }
 
 void BackgroundSyncManager::RunInBackgroundIfNecessary() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   base::TimeDelta soonest_wakeup_delta = base::TimeDelta::Max();
 
   for (const auto& sw_id_and_registrations : active_registrations_) {
     for (const auto& key_and_registration :
          sw_id_and_registrations.second.registration_map) {
       const BackgroundSyncRegistration& registration =
           key_and_registration.second;
-      if (registration.sync_state() == mojom::BackgroundSyncState::PENDING) {
+      if (registration.sync_state() ==
+          blink::mojom::BackgroundSyncState::PENDING) {
         if (clock_->Now() >= registration.delay_until()) {
           soonest_wakeup_delta = base::TimeDelta();
         } else {
           base::TimeDelta delay_delta =
               registration.delay_until() - clock_->Now();
           if (delay_delta < soonest_wakeup_delta)
             soonest_wakeup_delta = delay_delta;
         }
       }
     }
@@ skipping 50 matching lines @@
     const int64_t service_worker_id = sw_id_and_registrations.first;
     for (auto& key_and_registration :
          sw_id_and_registrations.second.registration_map) {
       BackgroundSyncRegistration* registration = &key_and_registration.second;
       if (IsRegistrationReadyToFire(*registration)) {
         sw_id_and_tags_to_fire.push_back(
             std::make_pair(service_worker_id, key_and_registration.first));
         // The state change is not saved to persistent storage because
         // if the sync event is killed mid-sync then it should return to
         // SYNC_STATE_PENDING.
-        registration->set_sync_state(mojom::BackgroundSyncState::FIRING);
+        registration->set_sync_state(blink::mojom::BackgroundSyncState::FIRING);
       }
     }
   }
 
   if (sw_id_and_tags_to_fire.empty()) {
     RunInBackgroundIfNecessary();
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
@@ skipping 44 matching lines @@
         FROM_HERE, base::Bind(event_completed_callback));
     return;
   }
 
   BackgroundSyncRegistration* registration =
       LookupActiveRegistration(service_worker_registration->id(), tag);
   DCHECK(registration);
 
   num_firing_registrations_ += 1;
 
-  mojom::BackgroundSyncEventLastChance last_chance =
+  blink::mojom::BackgroundSyncEventLastChance last_chance =
       registration->num_attempts() == parameters_->max_sync_attempts - 1
-          ? mojom::BackgroundSyncEventLastChance::IS_LAST_CHANCE
-          : mojom::BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE;
+          ? blink::mojom::BackgroundSyncEventLastChance::IS_LAST_CHANCE
+          : blink::mojom::BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE;
 
   HasMainFrameProviderHost(
       service_worker_registration->pattern().GetOrigin(),
       base::Bind(&BackgroundSyncMetrics::RecordEventStarted));
 
   DispatchSyncEvent(
       registration->options()->tag,
       service_worker_registration->active_version(), last_chance,
       base::Bind(&BackgroundSyncManager::EventComplete,
                  weak_ptr_factory_.GetWeakPtr(), service_worker_registration,
@@ skipping 50 matching lines @@
   num_firing_registrations_ -= 1;
 
   BackgroundSyncRegistration* registration =
       LookupActiveRegistration(service_worker_id, tag);
   if (!registration) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
-  DCHECK_NE(mojom::BackgroundSyncState::PENDING, registration->sync_state());
+  DCHECK_NE(blink::mojom::BackgroundSyncState::PENDING,
+            registration->sync_state());
 
   registration->set_num_attempts(registration->num_attempts() + 1);
 
   // The event ran to completion, we should count it, no matter what happens
   // from here.
   ServiceWorkerRegistration* sw_registration =
       service_worker_context_->GetLiveRegistration(service_worker_id);
   if (sw_registration) {
     HasMainFrameProviderHost(
         sw_registration->pattern().GetOrigin(),
         base::Bind(&BackgroundSyncMetrics::RecordEventResult,
                    status_code == SERVICE_WORKER_OK));
   }
 
   bool registration_completed = true;
   bool can_retry =
       registration->num_attempts() < parameters_->max_sync_attempts;
 
   if (registration->sync_state() ==
-      mojom::BackgroundSyncState::REREGISTERED_WHILE_FIRING) {
-    registration->set_sync_state(mojom::BackgroundSyncState::PENDING);
+      blink::mojom::BackgroundSyncState::REREGISTERED_WHILE_FIRING) {
+    registration->set_sync_state(blink::mojom::BackgroundSyncState::PENDING);
     registration->set_num_attempts(0);
     registration_completed = false;
   } else if (status_code != SERVICE_WORKER_OK &&
              can_retry) {  // Sync failed but can retry
-    registration->set_sync_state(mojom::BackgroundSyncState::PENDING);
+    registration->set_sync_state(blink::mojom::BackgroundSyncState::PENDING);
     registration->set_delay_until(clock_->Now() +
                                   parameters_->initial_retry_delay *
                                       pow(parameters_->retry_delay_factor,
                                           registration->num_attempts() - 1));
     registration_completed = false;
   }
 
   if (registration_completed) {
     const std::string& tag = registration->options()->tag;
     BackgroundSyncRegistration* active_registration =
@@ skipping 151 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