Rationalize WakeLock naming conventions

third_party/WebKit/Source/web/tests/ScreenWakeLockTest.cpp

 // 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 "modules/wake_lock/ScreenWakeLock.h"
 
 #include "core/dom/DOMImplementation.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentInit.h"
 #include "core/frame/WebLocalFrameBase.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebPageVisibilityState.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "web/tests/FrameTestHelpers.h"
 
 #include <memory>
 
 namespace blink {
 namespace {
 
-using device::mojom::blink::WakeLockService;
-using device::mojom::blink::WakeLockServiceRequest;
+using device::mojom::blink::WakeLock;
+using device::mojom::blink::WakeLockRequest;
 
-// This class allows binding interface requests to a MockWakeLockService.
+// This class allows binding interface requests to a MockWakeLock.
 class MockInterfaceProvider : public InterfaceProvider {
  public:
   MockInterfaceProvider() : wake_lock_status_(false) {}
   ~MockInterfaceProvider() {}
 
   void GetInterface(const char* name, mojo::ScopedMessagePipeHandle) override;
 
   bool WakeLockStatus() const { return wake_lock_status_; }
   void SetWakeLockStatus(bool status) { wake_lock_status_ = status; }
 
  private:
-  // A mock WakeLockService used to intercept calls to the mojo methods.
-  class MockWakeLockService : public WakeLockService {
+  // A mock WakeLock used to intercept calls to the mojo methods.
+  class MockWakeLock : public WakeLock {
    public:
-    MockWakeLockService(MockInterfaceProvider* registry,
-                        WakeLockServiceRequest request)
+    MockWakeLock(MockInterfaceProvider* registry, WakeLockRequest request)
         : binding_(this, std::move(request)), registry_(registry) {}
-    ~MockWakeLockService() {}
+    ~MockWakeLock() {}
 
    private:
-    // mojom::WakeLockService
+    // mojom::WakeLock
     void RequestWakeLock() override { registry_->SetWakeLockStatus(true); }
     void CancelWakeLock() override { registry_->SetWakeLockStatus(false); }
-    void AddClient(
-        device::mojom::blink::WakeLockServiceRequest wake_lock) override {}
+    void AddClient(device::mojom::blink::WakeLockRequest wake_lock) override {}
     void HasWakeLockForTests(HasWakeLockForTestsCallback callback) override {}
 
-    mojo::Binding<WakeLockService> binding_;
+    mojo::Binding<WakeLock> binding_;
     MockInterfaceProvider* const registry_;
   };
-  std::unique_ptr<MockWakeLockService> mock_wake_lock_service_;
+  std::unique_ptr<MockWakeLock> mock_wake_lock_;
 
   bool wake_lock_status_;
 };
 
 void MockInterfaceProvider::GetInterface(const char* name,
                                          mojo::ScopedMessagePipeHandle handle) {
-  mock_wake_lock_service_.reset(
-      new MockWakeLockService(this, WakeLockServiceRequest(std::move(handle))));
+  mock_wake_lock_.reset(
+      new MockWakeLock(this, WakeLockRequest(std::move(handle))));
 }
 
 // A TestWebFrameClient to allow overriding the interfaceProvider() with a mock.
 class TestWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
  public:
   ~TestWebFrameClient() override = default;
   InterfaceProvider* GetInterfaceProvider() override {
     return &interface_provider_;
   }
 
@@ skipping 129 matching lines @@
 
   SetKeepAwake(true);
   LoadFrame();
 
   EXPECT_FALSE(ScreenKeepAwake());
   EXPECT_FALSE(ClientKeepScreenAwake());
 }
 
 }  // namespace
 }  // namespace blink