Convert //content/browser/webrtc to be clients of WakeLock mojo service.

content/browser/webrtc/webrtc_internals_unittest.cc

 // Copyright (c) 2013 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/webrtc/webrtc_internals.h"
 
 #include <memory>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "content/browser/webrtc/webrtc_internals_ui_observer.h"
 #include "content/public/test/test_browser_thread.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 static const char kContraints[] = "c";
 static const char kRtcConfiguration[] = "r";
 static const char kUrl[] = "u";
 
@@ skipping 12 matching lines @@
     value_.reset(value ? value->DeepCopy() : nullptr);
     if (loop_)
       loop_->Quit();
   }
 
   std::string command_;
   std::unique_ptr<base::Value> value_;
   base::RunLoop* loop_;
 };
 
+class MockWakeLockService : public device::mojom::WakeLockService {
+ public:
+  MockWakeLockService(device::mojom::WakeLockServiceRequest request)
+      : binding_(this, std::move(request)), has_wakelock_(false) {}
+  ~MockWakeLockService() override {}
+
+  // Implement device::mojom::WakeLockService:
+  void RequestWakeLock() override { has_wakelock_ = true; }
+  void CancelWakeLock() override { has_wakelock_ = false; }
+  void AddClient(device::mojom::WakeLockServiceRequest request) override {}
+  void HasWakeLockForTests(
+      const HasWakeLockForTestsCallback& callback) override {}
+
+  bool HasWakeLock() {
+    base::RunLoop().RunUntilIdle();
+    return has_wakelock_;
+  }
+
+ private:
+  mojo::Binding<device::mojom::WakeLockService> binding_;
+  bool has_wakelock_;
+};
+
 // Derived class for testing only.  Allows the tests to have their own instance
 // for testing and control the period for which WebRTCInternals will bulk up
 // updates (changes down from 500ms to 1ms).
 class WebRTCInternalsForTest : public NON_EXPORTED_BASE(WebRTCInternals) {
  public:
-  WebRTCInternalsForTest() : WebRTCInternals(1, true) {}
+  WebRTCInternalsForTest()
+      : WebRTCInternals(1, true),
+        mock_wake_lock_service_(mojo::MakeRequest(&wake_lock_service_)) {}
   ~WebRTCInternalsForTest() override {}
+  bool HasWakeLock() { return mock_wake_lock_service_.HasWakeLock(); }
+
+ private:
+  MockWakeLockService mock_wake_lock_service_;
 };
 
 }  // namespace
 
 class WebRtcInternalsTest : public testing::Test {
  public:
   WebRtcInternalsTest() : io_thread_(BrowserThread::UI, &io_loop_) {}
 
  protected:
   void VerifyString(const base::DictionaryValue* dict,
@@ skipping 324 matching lines @@
 
   webrtc_internals.AddObserver(&observer);
   webrtc_internals.FileSelectionCanceled(nullptr);
 
   loop.Run();
 
   EXPECT_EQ("audioDebugRecordingsFileSelectionCancelled", observer.command());
   EXPECT_EQ(nullptr, observer.value());
 }
 
-TEST_F(WebRtcInternalsTest, PowerSaveBlock) {
+TEST_F(WebRtcInternalsTest, WakeLock) {
   int kRenderProcessId = 1;
   const int pid = 1;
   const int lid[] = {1, 2, 3};
 
   WebRTCInternalsForTest webrtc_internals;
 
   // Add a few peer connections.
   EXPECT_EQ(0, webrtc_internals.num_open_connections());
-  EXPECT_FALSE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_FALSE(webrtc_internals.HasWakeLock());
   webrtc_internals.OnAddPeerConnection(kRenderProcessId, pid, lid[0], kUrl,
                                        kRtcConfiguration, kContraints);
   EXPECT_EQ(1, webrtc_internals.num_open_connections());
-  EXPECT_TRUE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_TRUE(webrtc_internals.HasWakeLock());
 
   webrtc_internals.OnAddPeerConnection(kRenderProcessId, pid, lid[1], kUrl,
                                        kRtcConfiguration, kContraints);
   EXPECT_EQ(2, webrtc_internals.num_open_connections());
-  EXPECT_TRUE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_TRUE(webrtc_internals.HasWakeLock());
 
   webrtc_internals.OnAddPeerConnection(kRenderProcessId, pid, lid[2], kUrl,
                                        kRtcConfiguration, kContraints);
   EXPECT_EQ(3, webrtc_internals.num_open_connections());
-  EXPECT_TRUE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_TRUE(webrtc_internals.HasWakeLock());
 
   // Remove a peer connection without closing it first.
   webrtc_internals.OnRemovePeerConnection(pid, lid[2]);
   EXPECT_EQ(2, webrtc_internals.num_open_connections());
-  EXPECT_TRUE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_TRUE(webrtc_internals.HasWakeLock());
 
   // Close the remaining peer connections.
   webrtc_internals.OnUpdatePeerConnection(pid, lid[1], "stop", std::string());
   EXPECT_EQ(1, webrtc_internals.num_open_connections());
-  EXPECT_TRUE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_TRUE(webrtc_internals.HasWakeLock());
 
   webrtc_internals.OnUpdatePeerConnection(pid, lid[0], "stop", std::string());
   EXPECT_EQ(0, webrtc_internals.num_open_connections());
-  EXPECT_FALSE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_FALSE(webrtc_internals.HasWakeLock());
 
   // Remove the remaining peer connections.
   webrtc_internals.OnRemovePeerConnection(pid, lid[1]);
   EXPECT_EQ(0, webrtc_internals.num_open_connections());
-  EXPECT_FALSE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_FALSE(webrtc_internals.HasWakeLock());
 
   webrtc_internals.OnRemovePeerConnection(pid, lid[0]);
   EXPECT_EQ(0, webrtc_internals.num_open_connections());
-  EXPECT_FALSE(webrtc_internals.IsPowerSavingBlocked());
+  EXPECT_FALSE(webrtc_internals.HasWakeLock());
 }
 
 }  // namespace content