Change mojo enums to be scoped enums in the generated C++ bindings.

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"
@@ skipping 510 matching lines @@
           AreOptionConditionsMet(options)
               ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
               : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
       BackgroundSyncMetrics::CountRegisterSuccess(
           existing_registration->options()->periodicity,
           registration_could_fire,
           BackgroundSyncMetrics::REGISTRATION_IS_DUPLICATE);
 
     if (existing_registration->IsFiring()) {
       existing_registration->set_sync_state(
-          BACKGROUND_SYNC_STATE_REREGISTERED_WHILE_FIRING);
+          BackgroundSyncState::REREGISTERED_WHILE_FIRING);
     }
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(
             callback, BACKGROUND_SYNC_STATUS_OK,
             base::Passed(CreateRegistrationHandle(existing_registration_ref))));
     return;
     } else {
       existing_registration_ref->value()->SetUnregisteredState();
@@ skipping 416 matching lines @@
 }
 
 void BackgroundSyncManager::NotifyWhenFinished(
     BackgroundSyncRegistrationHandle::HandleId handle_id,
     const StatusAndStateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-                              BACKGROUND_SYNC_STATE_FAILED));
+                              BackgroundSyncState::FAILED));
     return;
   }
 
   scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle =
       DuplicateRegistrationHandle(handle_id);
 
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::NotifyWhenFinishedImpl,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(registration_handle)), callback));
 }
 
 void BackgroundSyncManager::NotifyWhenFinishedImpl(
     scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
     const StatusAndStateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(SYNC_ONE_SHOT, registration_handle->options()->periodicity);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-                              BACKGROUND_SYNC_STATE_FAILED));
+                              BackgroundSyncState::FAILED));
     return;
   }
 
   if (!registration_handle->registration()->HasCompleted()) {
     registration_handle->registration()->AddFinishedCallback(
         base::Bind(&BackgroundSyncManager::NotifyWhenFinishedInvokeCallback,
                    weak_ptr_factory_.GetWeakPtr(), callback));
     op_scheduler_.CompleteOperationAndRunNext();
     return;
   }
@@ skipping 79 matching lines @@
 }
 
 bool BackgroundSyncManager::IsRegistrationReadyToFire(
     const BackgroundSyncRegistration& registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(jkarlin): Add support for firing periodic registrations.
   if (registration.options()->periodicity == SYNC_PERIODIC)
     return false;
 
-  if (registration.sync_state() != BACKGROUND_SYNC_STATE_PENDING)
+  if (registration.sync_state() != BackgroundSyncState::PENDING)
     return false;
 
   if (clock_->Now() < registration.delay_until())
     return false;
 
   DCHECK_EQ(SYNC_ONE_SHOT, registration.options()->periodicity);
 
   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->value();
-      if (registration.sync_state() == BACKGROUND_SYNC_STATE_PENDING) {
+      if (registration.sync_state() == BackgroundSyncState::PENDING) {
         if (registration.options()->periodicity == SYNC_ONE_SHOT) {
           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;
           }
         } else {
@@ skipping 57 matching lines @@
     for (auto& key_and_registration :
          sw_id_and_registrations.second.registration_map) {
       BackgroundSyncRegistration* registration =
           key_and_registration.second->value();
       if (IsRegistrationReadyToFire(*registration)) {
         sw_id_and_keys_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(BACKGROUND_SYNC_STATE_FIRING);
+        registration->set_sync_state(BackgroundSyncState::FIRING);
       }
     }
   }
 
   if (sw_id_and_keys_to_fire.empty()) {
     RunInBackgroundIfNecessary();
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
@@ skipping 55 matching lines @@
       CreateRegistrationHandle(registration);
 
   num_firing_registrations_ += 1;
 
   BackgroundSyncRegistrationHandle::HandleId handle_id =
       registration_handle->handle_id();
 
   BackgroundSyncEventLastChance last_chance =
       registration->value()->num_attempts() ==
               parameters_->max_sync_attempts - 1
-          ? BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE
-          : BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_NOT_LAST_CHANCE;
+          ? BackgroundSyncEventLastChance::IS_LAST_CHANCE
+          : BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE;
 
   HasMainFrameProviderHost(
       service_worker_registration->pattern().GetOrigin(),
       base::Bind(&BackgroundSyncMetrics::RecordEventStarted,
                  registration->value()->options()->periodicity));
 
   FireOneShotSync(
       handle_id, service_worker_registration->active_version(), last_chance,
       base::Bind(&BackgroundSyncManager::EventComplete,
                  weak_ptr_factory_.GetWeakPtr(), service_worker_registration,
@@ skipping 55 matching lines @@
   if (sw_registration) {
     HasMainFrameProviderHost(
         sw_registration->pattern().GetOrigin(),
         base::Bind(&BackgroundSyncMetrics::RecordEventResult,
                    registration->options()->periodicity,
                    status_code == SERVICE_WORKER_OK));
   }
 
   if (registration->options()->periodicity == SYNC_ONE_SHOT) {
     if (registration->sync_state() ==
-        BACKGROUND_SYNC_STATE_REREGISTERED_WHILE_FIRING) {
-      registration->set_sync_state(BACKGROUND_SYNC_STATE_PENDING);
+        BackgroundSyncState::REREGISTERED_WHILE_FIRING) {
+      registration->set_sync_state(BackgroundSyncState::PENDING);
       registration->set_num_attempts(0);
     } else if (status_code != SERVICE_WORKER_OK) {  // Sync failed
       bool can_retry =
           registration->num_attempts() < parameters_->max_sync_attempts;
       if (registration->sync_state() ==
-          BACKGROUND_SYNC_STATE_UNREGISTERED_WHILE_FIRING) {
+          BackgroundSyncState::UNREGISTERED_WHILE_FIRING) {
         registration->set_sync_state(can_retry
-                                         ? BACKGROUND_SYNC_STATE_UNREGISTERED
-                                         : BACKGROUND_SYNC_STATE_FAILED);
+                                         ? BackgroundSyncState::UNREGISTERED
+                                         : BackgroundSyncState::FAILED);
         registration->RunFinishedCallbacks();
       } else if (can_retry) {
-        registration->set_sync_state(BACKGROUND_SYNC_STATE_PENDING);
+        registration->set_sync_state(BackgroundSyncState::PENDING);
         registration->set_delay_until(
             clock_->Now() +
             parameters_->initial_retry_delay *
                 pow(parameters_->retry_delay_factor,
                     registration->num_attempts() - 1));
       } else {
-        registration->set_sync_state(BACKGROUND_SYNC_STATE_FAILED);
+        registration->set_sync_state(BackgroundSyncState::FAILED);
         registration->RunFinishedCallbacks();
       }
     } else {  // Sync succeeded
-      registration->set_sync_state(BACKGROUND_SYNC_STATE_SUCCESS);
+      registration->set_sync_state(BackgroundSyncState::SUCCESS);
       registration->RunFinishedCallbacks();
     }
 
     if (registration->HasCompleted()) {
       RegistrationKey key(*registration);
       RefCountedRegistration* active_registration =
           LookupActiveRegistration(service_worker_id, key);
       if (active_registration &&
           active_registration->value()->id() == registration->id()) {
         RemoveActiveRegistration(service_worker_id, key);
@@ skipping 164 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