Merge PowerSaveBlockerImpl and PowerSaveBlocker

extensions/browser/api/power/power_api_unittest.cc

 // Copyright 2014 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 "extensions/browser/api/power/power_api.h"
 
 #include <deque>
 #include <memory>
 #include <string>
 
@@ skipping 24 matching lines @@
   UNBLOCK_DISPLAY_SLEEP,
   // Returned by PowerSaveBlockerStubManager::PopFirstRequest() when no
   // requests are present.
   NONE,
 };
 
 // Stub implementation of device::PowerSaveBlocker that just runs a callback on
 // destruction.
 class PowerSaveBlockerStub : public device::PowerSaveBlocker {
  public:
-  explicit PowerSaveBlockerStub(base::Closure unblock_callback)
-      : unblock_callback_(unblock_callback) {
-  }
+  PowerSaveBlockerStub(
+      base::Closure unblock_callback,
+      scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner)
+      : PowerSaveBlocker(PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
+                         PowerSaveBlocker::kReasonOther,
+                         "test",
+                         ui_task_runner,
+                         blocking_task_runner),
+        unblock_callback_(unblock_callback) {}
 
   ~PowerSaveBlockerStub() override { unblock_callback_.Run(); }
 
  private:
   base::Closure unblock_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerSaveBlockerStub);
 };
 
 // Manages PowerSaveBlockerStub objects.  Tests can instantiate this class
@@ skipping 28 matching lines @@
     return request;
   }
 
  private:
   // Creates a new PowerSaveBlockerStub of type |type|.
   std::unique_ptr<device::PowerSaveBlocker> CreateStub(
       device::PowerSaveBlocker::PowerSaveBlockerType type,
       device::PowerSaveBlocker::Reason reason,
       const std::string& description,
       scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
+      scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner) {
     Request unblock_request = NONE;
     switch (type) {
       case device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension:
         requests_.push_back(BLOCK_APP_SUSPENSION);
         unblock_request = UNBLOCK_APP_SUSPENSION;
         break;
       case device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep:
         requests_.push_back(BLOCK_DISPLAY_SLEEP);
         unblock_request = UNBLOCK_DISPLAY_SLEEP;
         break;
     }
     return std::unique_ptr<device::PowerSaveBlocker>(new PowerSaveBlockerStub(
         base::Bind(&PowerSaveBlockerStubManager::AppendRequest,
-                   weak_ptr_factory_.GetWeakPtr(), unblock_request)));
+                   weak_ptr_factory_.GetWeakPtr(), unblock_request),
+        ui_task_runner, blocking_task_runner));
   }
 
   void AppendRequest(Request request) {
     requests_.push_back(request);
   }
 
   content::BrowserContext* browser_context_;
 
   // Requests in chronological order.
   std::deque<Request> requests_;
@@ skipping 148 matching lines @@
   EXPECT_EQ(NONE, manager_->PopFirstRequest());
 
   // Make the first extension block display-sleep again.
   ASSERT_TRUE(CallFunction(REQUEST, kDisplayArgs, extension()));
   EXPECT_EQ(BLOCK_DISPLAY_SLEEP, manager_->PopFirstRequest());
   EXPECT_EQ(UNBLOCK_APP_SUSPENSION, manager_->PopFirstRequest());
   EXPECT_EQ(NONE, manager_->PopFirstRequest());
 }
 
 }  // namespace extensions