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

content/browser/background_sync/background_sync_manager_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_manager.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
@@ skipping 271 matching lines @@
   void HasMainFrameProviderHost(const GURL& origin,
                                 const BoolCallback& callback) override {
     callback.Run(has_main_frame_provider_host_);
   }
 
  private:
   bool corrupt_backend_ = false;
   bool delay_backend_ = false;
   bool has_main_frame_provider_host_ = true;
   BackgroundSyncEventLastChance last_chance_ =
-      BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_NOT_LAST_CHANCE;
+      BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE;
   base::Closure continuation_;
   OneShotCallback one_shot_callback_;
   base::Closure delayed_task_;
   base::TimeDelta delayed_task_delta_;
 };
 
 class BackgroundSyncManagerTest : public testing::Test {
  public:
   BackgroundSyncManagerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
@@ skipping 223 matching lines @@
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   bool NotifyWhenFinished(
       BackgroundSyncRegistrationHandle* registration_handle) {
     callback_finished_called_ = false;
     callback_finished_status_ = BACKGROUND_SYNC_STATUS_NOT_FOUND;
-    callback_finished_state_ = BACKGROUND_SYNC_STATE_FAILED;
+    callback_finished_state_ = BackgroundSyncState::FAILED;
 
     registration_handle->NotifyWhenFinished(
         base::Bind(&NotifyWhenFinishedCallback, &callback_finished_called_,
                    &callback_finished_status_, &callback_finished_state_));
     base::RunLoop().RunUntilIdle();
 
     if (callback_finished_called_)
       EXPECT_EQ(BACKGROUND_SYNC_STATUS_OK, callback_finished_status_);
 
     return callback_finished_called_;
@@ skipping 137 matching lines @@
 
   // Callback values.
   BackgroundSyncStatus callback_status_ = BACKGROUND_SYNC_STATUS_OK;
   scoped_ptr<BackgroundSyncRegistrationHandle> callback_registration_handle_;
   scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
       callback_registration_handles_;
   ServiceWorkerStatusCode callback_sw_status_code_ = SERVICE_WORKER_OK;
   bool callback_finished_called_ = false;
   BackgroundSyncStatus callback_finished_status_ =
       BACKGROUND_SYNC_STATUS_NOT_FOUND;
-  BackgroundSyncState callback_finished_state_ = BACKGROUND_SYNC_STATE_FAILED;
+  BackgroundSyncState callback_finished_state_ = BackgroundSyncState::FAILED;
   int sync_events_called_ = 0;
   ServiceWorkerVersion::StatusCallback sync_fired_callback_;
 };
 
 TEST_F(BackgroundSyncManagerTest, Register) {
   EXPECT_TRUE(Register(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistractionIntact) {
   EXPECT_TRUE(Register(sync_options_1_));
@@ skipping 478 matching lines @@
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, NotifyWhenFinishedAfterEventSuccess) {
   InitSyncEventTest();
 
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(1, sync_events_called_);
 
   EXPECT_TRUE(NotifyWhenFinished(callback_registration_handle_.get()));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, NotifyWhenFinishedBeforeEventSuccess) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
 
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Finish firing the event.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, sync_events_called_);
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest,
        NotifyWhenFinishedBeforeUnregisteredEventSuccess) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Unregistering should set the state to UNREGISTERED but finished shouldn't
   // be called until the event finishes firing, at which point its state should
   // be SUCCESS.
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 
   // Finish firing the event.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest,
        NotifyWhenFinishedBeforeUnregisteredEventFailure) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Unregistering should set the state to UNREGISTERED but finished shouldn't
   // be called until the event finishes firing, at which point its state should
   // be FAILED.
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 
   // Finish firing the event.
   sync_fired_callback_.Run(SERVICE_WORKER_ERROR_FAILED);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, sync_events_called_);
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_FAILED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::FAILED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest,
        NotifyWhenFinishedBeforeUnregisteredEventFires) {
   InitSyncEventTest();
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
   EXPECT_TRUE(NotifyWhenFinished(callback_registration_handle_.get()));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::UNREGISTERED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest,
        NotifyWhenFinishedBeforeEventSuccessDroppedHandle) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Drop the client's handle to the registration before the event fires, ensure
   // that the finished callback is still run.
   callback_registration_handle_ = nullptr;
 
   // Finish firing the event.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, sync_events_called_);
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, NotifyWhenFinishedAfterEventFailure) {
   InitFailedSyncEventTest();
 
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(1, sync_events_called_);
 
   EXPECT_TRUE(NotifyWhenFinished(callback_registration_handle_.get()));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_FAILED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::FAILED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, NotifyWhenFinishedBeforeEventFailure) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Finish firing the event.
   sync_fired_callback_.Run(SERVICE_WORKER_ERROR_FAILED);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_FAILED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::FAILED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, NotifyWhenFinishedAfterUnregistered) {
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
 
   EXPECT_TRUE(NotifyWhenFinished(callback_registration_handle_.get()));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::UNREGISTERED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, NotifyWhenFinishedBeforeUnregistered) {
   Register(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::UNREGISTERED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, ReregisterMidSyncFirstAttemptFails) {
   InitDelayedSyncEventTest();
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Reregister the event mid-sync
   EXPECT_TRUE(Register(sync_options_1_));
 
   // The first sync attempt fails.
   sync_fired_callback_.Run(SERVICE_WORKER_ERROR_FAILED);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_finished_called_);
 
   // It should fire again since it was reregistered mid-sync.
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, ReregisterMidSyncFirstAttemptSucceeds) {
   InitDelayedSyncEventTest();
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Reregister the event mid-sync
   EXPECT_TRUE(Register(sync_options_1_));
 
   // The first sync event succeeds.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_finished_called_);
 
   // It should fire again since it was reregistered mid-sync.
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   EXPECT_FALSE(GetRegistration(sync_options_1_));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest,
        NotifyUnregisteredMidSyncNoRetryAttemptsLeft) {
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Unregister the event mid-sync.
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
 
   // Finish firing the event.
   sync_fired_callback_.Run(SERVICE_WORKER_ERROR_FAILED);
   base::RunLoop().RunUntilIdle();
 
   // Since there were no retry attempts left, the sync ultimately failed.
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_FAILED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::FAILED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest,
        NotifyUnregisteredMidSyncWithRetryAttemptsLeft) {
   SetMaxSyncAttemptsAndRestartManager(2);
   InitDelayedSyncEventTest();
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Unregister the event mid-sync.
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
 
   // Finish firing the event.
   sync_fired_callback_.Run(SERVICE_WORKER_ERROR_FAILED);
   base::RunLoop().RunUntilIdle();
   // Since there was one retry attempt left, the sync didn't completely fail
   // before it was unregistered.
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::UNREGISTERED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwritePendingRegistration) {
   // An overwritten pending registration should complete with
-  // BACKGROUND_SYNC_STATE_UNREGISTERED.
+  // BackgroundSyncState::UNREGISTERED.
   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_EQ(POWER_STATE_AVOID_DRAINING,
             callback_registration_handle_->options()->power_state);
   scoped_ptr<BackgroundSyncRegistrationHandle> original_handle =
       std::move(callback_registration_handle_);
 
   // Overwrite the pending registration.
   sync_options_1_.power_state = POWER_STATE_AUTO;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_EQ(POWER_STATE_AUTO,
             callback_registration_handle_->options()->power_state);
 
   EXPECT_TRUE(NotifyWhenFinished(original_handle.get()));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::UNREGISTERED, FinishedState());
   EXPECT_EQ(0, sync_events_called_);
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwriteFiringRegistrationWhichSucceeds) {
   // An overwritten pending registration should complete with
-  // BACKGROUND_SYNC_STATE_SUCCESS if firing completes successfully.
+  // BackgroundSyncState::SUCCESS if firing completes successfully.
   InitDelayedSyncEventTest();
 
   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   scoped_ptr<BackgroundSyncRegistrationHandle> original_handle =
       std::move(callback_registration_handle_);
 
   // The next registration won't block.
   InitSyncEventTest();
 
   // Overwrite the firing registration.
   sync_options_1_.power_state = POWER_STATE_AUTO;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_FALSE(NotifyWhenFinished(original_handle.get()));
 
   // Successfully finish the first event.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwriteFiringRegistrationWhichFails) {
   // An overwritten pending registration should complete with
-  // BACKGROUND_SYNC_STATE_FAILED if firing fails.
+  // BackgroundSyncState::FAILED if firing fails.
   InitDelayedSyncEventTest();
 
   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   scoped_ptr<BackgroundSyncRegistrationHandle> original_handle =
       std::move(callback_registration_handle_);
 
   // The next registration won't block.
   InitSyncEventTest();
 
   // Overwrite the firing registration.
   sync_options_1_.power_state = POWER_STATE_AUTO;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_FALSE(NotifyWhenFinished(original_handle.get()));
 
   // Fail the first event.
   sync_fired_callback_.Run(SERVICE_WORKER_ERROR_FAILED);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_FAILED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::FAILED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, DisableWhilePendingNotifiesFinished) {
   InitSyncEventTest();
 
   // Register a one-shot that must wait for network connectivity before it
   // can fire.
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Corrupting the backend should result in the manager disabling itself on the
   // next operation. While disabling, it should finalize any pending
   // registrations.
   test_background_sync_manager_->set_corrupt_backend(true);
   EXPECT_FALSE(Register(sync_options_2_));
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::UNREGISTERED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, DisableWhileFiringNotifiesFinished) {
   InitDelayedSyncEventTest();
 
   // Register a one-shot that pauses mid-fire.
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
   EXPECT_FALSE(NotifyWhenFinished(callback_registration_handle_.get()));
 
   // Corrupting the backend should result in the manager disabling itself on the
   // next operation. Even though the manager is disabled, the firing sync event
   // should still be able to complete successfully and notify as much.
   test_background_sync_manager_->set_corrupt_backend(true);
   EXPECT_FALSE(Register(sync_options_2_));
   EXPECT_FALSE(callback_finished_called_);
   test_background_sync_manager_->set_corrupt_backend(false);
 
   // Successfully complete the firing event.
   sync_fired_callback_.Run(SERVICE_WORKER_OK);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(BACKGROUND_SYNC_STATE_SUCCESS, FinishedState());
+  EXPECT_EQ(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 // TODO(jkarlin): Change this to a periodic test as one-shots can't be power
 // dependent according to spec.
 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnPowerChange) {
   InitSyncEventTest();
   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
 
   SetOnBatteryPower(true);
   EXPECT_TRUE(Register(sync_options_1_));
@@ skipping 506 matching lines @@
 
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_FALSE(GetRegistration(sync_options_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, LastChance) {
   SetMaxSyncAttemptsAndRestartManager(2);
   InitFailedSyncEventTest();
 
   EXPECT_TRUE(Register(sync_options_1_));
-  EXPECT_EQ(BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_NOT_LAST_CHANCE,
+  EXPECT_EQ(BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   // Run it again.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
   test_background_sync_manager_->delayed_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
-  EXPECT_EQ(BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE,
+  EXPECT_EQ(BackgroundSyncEventLastChance::IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content