[BackgroundSync Cleanup] Remove power observer

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"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
-#include "base/power_monitor/power_monitor.h"
-#include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/simple_test_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/background_sync/background_sync_registration_handle.h"
 #include "content/browser/background_sync/background_sync_status.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
@@ skipping 70 matching lines @@
 void NotifyWhenFinishedCallback(bool* was_called,
                                 BackgroundSyncStatus* out_status,
                                 BackgroundSyncState* out_state,
                                 BackgroundSyncStatus status,
                                 BackgroundSyncState state) {
   *was_called = true;
   *out_status = status;
   *out_state = state;
 }
 
-class TestPowerSource : public base::PowerMonitorSource {
- public:
-  void GeneratePowerStateEvent(bool on_battery_power) {
-    test_on_battery_power_ = on_battery_power;
-    ProcessPowerEvent(POWER_STATE_EVENT);
-  }
-
- private:
-  bool IsOnBatteryPowerImpl() final { return test_on_battery_power_; }
-  bool test_on_battery_power_ = false;
-};
-
 class TestBackgroundSyncController : public BackgroundSyncController {
  public:
   TestBackgroundSyncController() = default;
 
   // BackgroundSyncController Overrides
   void NotifyBackgroundSyncRegistered(const GURL& origin) override {
     registration_count_ += 1;
     registration_origin_ = origin;
   }
   void RunInBackground(bool enabled, int64_t min_ms) override {
@@ skipping 168 matching lines @@
 };
 
 class BackgroundSyncManagerTest : public testing::Test {
  public:
   BackgroundSyncManagerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         network_change_notifier_(net::NetworkChangeNotifier::CreateMock()) {
     sync_options_1_.tag = "foo";
     sync_options_1_.periodicity = SYNC_ONE_SHOT;
     sync_options_1_.network_state = NETWORK_STATE_ONLINE;
-    sync_options_1_.power_state = POWER_STATE_AUTO;
 
     sync_options_2_.tag = "bar";
     sync_options_2_.periodicity = SYNC_ONE_SHOT;
     sync_options_2_.network_state = NETWORK_STATE_ONLINE;
-    sync_options_2_.power_state = POWER_STATE_AUTO;
   }
 
   void SetUp() override {
     // Don't let the tests be confused by the real-world device connectivity
     background_sync_test_util::SetIgnoreNetworkChangeNotifier(true);
 
     // TODO(jkarlin): Create a new object with all of the necessary SW calls
     // so that we can inject test versions instead of bringing up all of this
     // extra SW stuff.
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
 
     // Create a StoragePartition with the correct BrowserContext so that the
     // BackgroundSyncManager can find the BrowserContext through it.
     storage_partition_impl_.reset(new StoragePartitionImpl(
         helper_->browser_context(), base::FilePath(), nullptr, nullptr, nullptr,
         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
         nullptr, nullptr, nullptr, nullptr));
     helper_->context_wrapper()->set_storage_partition(
         storage_partition_impl_.get());
 
-    power_monitor_source_ = new TestPowerSource();
-    // power_monitor_ takes ownership of power_monitor_source.
-    power_monitor_.reset(new base::PowerMonitor(
-        scoped_ptr<base::PowerMonitorSource>(power_monitor_source_)));
-
-    SetOnBatteryPower(false);
-
     scoped_ptr<TestBackgroundSyncController> background_sync_controller(
         new TestBackgroundSyncController());
     test_controller_ = background_sync_controller.get();
     helper_->browser_context()->SetBackgroundSyncController(
         std::move(background_sync_controller));
 
     SetMaxSyncAttemptsAndRestartManager(1);
 
     // Wait for storage to finish initializing before registering service
     // workers.
@@ skipping 41 matching lines @@
         connection_type);
     if (test_background_sync_manager_) {
       BackgroundSyncNetworkObserver* network_observer =
           test_background_sync_manager_->GetNetworkObserverForTesting();
       network_observer->NotifyManagerIfNetworkChangedForTesting(
           connection_type);
       base::RunLoop().RunUntilIdle();
     }
   }
 
-  void SetOnBatteryPower(bool on_battery_power) {
-    power_monitor_source_->GeneratePowerStateEvent(on_battery_power);
-    base::RunLoop().RunUntilIdle();
-  }
-
   void StatusAndRegistrationCallback(
       bool* was_called,
       BackgroundSyncStatus status,
       scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle) {
     *was_called = true;
     callback_status_ = status;
     callback_registration_handle_ = std::move(registration_handle);
   }
 
   void StatusAndRegistrationsCallback(
@@ skipping 242 matching lines @@
     BackgroundSyncParameters* parameters =
         test_controller_->background_sync_parameters();
     parameters->max_sync_attempts = max_sync_attempts;
 
     // Restart the BackgroundSyncManager so that it updates its parameters.
     SetupBackgroundSyncManager();
   }
 
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
-  TestPowerSource* power_monitor_source_ = nullptr;  // owned by power_monitor_
-  scoped_ptr<base::PowerMonitor> power_monitor_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
   scoped_ptr<BackgroundSyncManager> background_sync_manager_;
   scoped_ptr<StoragePartitionImpl> storage_partition_impl_;
   TestBackgroundSyncManager* test_background_sync_manager_ = nullptr;
   TestBackgroundSyncController* test_controller_;
   base::SimpleTestClock* test_clock_ = nullptr;
 
   int64_t sw_registration_id_1_;
   int64_t sw_registration_id_2_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_1_;
@@ skipping 417 matching lines @@
 
 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsNetworkState) {
   BackgroundSyncRegistration reg_1;
   BackgroundSyncRegistration reg_2;
   EXPECT_TRUE(reg_1.Equals(reg_2));
   reg_1.options()->network_state = NETWORK_STATE_ANY;
   reg_2.options()->network_state = NETWORK_STATE_ONLINE;
   EXPECT_FALSE(reg_1.Equals(reg_2));
 }
 
-TEST_F(BackgroundSyncManagerTest, RegistrationEqualsPowerState) {
-  BackgroundSyncRegistration reg_1;
-  BackgroundSyncRegistration reg_2;
-  EXPECT_TRUE(reg_1.Equals(reg_2));
-  reg_1.options()->power_state = POWER_STATE_AUTO;
-  reg_2.options()->power_state = POWER_STATE_AVOID_DRAINING;
-  EXPECT_FALSE(reg_1.Equals(reg_2));
-}
-
 TEST_F(BackgroundSyncManagerTest, StoreAndRetrievePreservesValues) {
   BackgroundSyncRegistrationOptions options;
   // Set non-default values for each field.
   options.tag = "foo";
   EXPECT_NE(SYNC_PERIODIC, options.periodicity);
   options.periodicity = SYNC_PERIODIC;
   options.min_period += 1;
   EXPECT_NE(NETWORK_STATE_ANY, options.network_state);
   options.network_state = NETWORK_STATE_ANY;
-  EXPECT_NE(POWER_STATE_AUTO, options.power_state);
-  options.power_state = POWER_STATE_AUTO;
 
   // Store the registration.
   EXPECT_TRUE(Register(options));
 
   // Simulate restarting the sync manager, forcing the next read to come from
   // disk.
   SetupBackgroundSyncManager();
 
   EXPECT_TRUE(GetRegistration(options));
   EXPECT_TRUE(options.Equals(*callback_registration_handle_->options()));
@@ skipping 247 matching lines @@
   // 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(BackgroundSyncState::UNREGISTERED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwritePendingRegistration) {
   // An overwritten pending registration should complete with
-  // BackgroundSyncState::UNREGISTERED.
-  sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
+  // BACKGROUND_SYNC_STATE_UNREGISTERED.
+  sync_options_1_.network_state = NETWORK_STATE_AVOID_CELLULAR;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
-  EXPECT_EQ(POWER_STATE_AVOID_DRAINING,
-            callback_registration_handle_->options()->power_state);
+  EXPECT_EQ(NETWORK_STATE_AVOID_CELLULAR,
+            callback_registration_handle_->options()->network_state);
   scoped_ptr<BackgroundSyncRegistrationHandle> original_handle =
       std::move(callback_registration_handle_);
 
   // Overwrite the pending registration.
-  sync_options_1_.power_state = POWER_STATE_AUTO;
+  sync_options_1_.network_state = NETWORK_STATE_ONLINE;
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
-  EXPECT_EQ(POWER_STATE_AUTO,
-            callback_registration_handle_->options()->power_state);
+  EXPECT_EQ(NETWORK_STATE_ONLINE,
+            callback_registration_handle_->options()->network_state);
 
   EXPECT_TRUE(NotifyWhenFinished(original_handle.get()));
   EXPECT_EQ(BackgroundSyncState::UNREGISTERED, FinishedState());
   EXPECT_EQ(0, sync_events_called_);
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwriteFiringRegistrationWhichSucceeds) {
   // An overwritten pending registration should complete with
   // BackgroundSyncState::SUCCESS if firing completes successfully.
   InitDelayedSyncEventTest();
 
-  sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
+  sync_options_1_.network_state = NETWORK_STATE_AVOID_CELLULAR;
   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;
+  sync_options_1_.network_state = NETWORK_STATE_ONLINE;
   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(BackgroundSyncState::SUCCESS, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, OverwriteFiringRegistrationWhichFails) {
   // An overwritten pending registration should complete with
   // BackgroundSyncState::FAILED if firing fails.
   InitDelayedSyncEventTest();
 
-  sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
+  sync_options_1_.network_state = NETWORK_STATE_AVOID_CELLULAR;
   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;
+  sync_options_1_.network_state = NETWORK_STATE_ONLINE;
   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(BackgroundSyncState::FAILED, FinishedState());
 }
 
 TEST_F(BackgroundSyncManagerTest, DisableWhilePendingNotifiesFinished) {
@@ skipping 27 matching lines @@
   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(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_));
-  EXPECT_EQ(0, sync_events_called_);
-  EXPECT_TRUE(GetRegistration(sync_options_1_));
-
-  SetOnBatteryPower(false);
-  EXPECT_EQ(1, sync_events_called_);
-  EXPECT_FALSE(GetRegistration(sync_options_1_));
-}
-
-// TODO(jkarlin): Change this to a periodic test as one-shots can't be power
-// dependent according to spec.
-TEST_F(BackgroundSyncManagerTest, MultipleOneShotsFireOnPowerChange) {
-  InitSyncEventTest();
-  sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
-  sync_options_2_.power_state = POWER_STATE_AVOID_DRAINING;
-
-  SetOnBatteryPower(true);
-  EXPECT_TRUE(Register(sync_options_1_));
-  EXPECT_TRUE(Register(sync_options_2_));
-  EXPECT_EQ(0, sync_events_called_);
-  EXPECT_TRUE(GetRegistration(sync_options_1_));
-  EXPECT_TRUE(GetRegistration(sync_options_2_));
-
-  SetOnBatteryPower(false);
-  EXPECT_EQ(2, sync_events_called_);
-  EXPECT_FALSE(GetRegistration(sync_options_1_));
-  EXPECT_FALSE(GetRegistration(sync_options_2_));
-}
-
 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnNetworkChange) {
   InitSyncEventTest();
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(0, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   base::RunLoop().RunUntilIdle();
@@ skipping 482 matching lines @@
   // 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(BackgroundSyncEventLastChance::IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content