Rename KeyLock to KeyboardLock and return enum from IPC

third_party/WebKit/Source/modules/keyboard_lock/NavigatorKeyboardLock.cpp

 // Copyright 2017 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/keyboard_lock/NavigatorKeyboardLock.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 11 matching lines @@
   NavigatorKeyboardLock* supplement = static_cast<NavigatorKeyboardLock*>(
       Supplement<Navigator>::From(navigator, SupplementName()));
   if (!supplement) {
     supplement = new NavigatorKeyboardLock(navigator);
     ProvideTo(navigator, SupplementName(), supplement);
   }
   return *supplement;
 }
 
 // static
-ScriptPromise NavigatorKeyboardLock::requestKeyLock(
+ScriptPromise NavigatorKeyboardLock::requestKeyboardLock(
     ScriptState* state,
     Navigator& navigator,
     const Vector<String>& keycodes) {
-  return NavigatorKeyboardLock::From(navigator).requestKeyLock(state, keycodes);
+  return NavigatorKeyboardLock::From(navigator).requestKeyboardLock(
+      state, keycodes);
 }
 
-ScriptPromise NavigatorKeyboardLock::requestKeyLock(
+ScriptPromise NavigatorKeyboardLock::requestKeyboardLock(
     ScriptState* state,
     const Vector<String>& keycodes) {
   DCHECK(state);
   if (request_keylock_resolver_) {
     // TODO(zijiehe): Reject with a DOMException once it has been defined in the
     // spec. See https://github.com/w3c/keyboard-lock/issues/18.
     return ScriptPromise::Reject(
         state, V8String(state->GetIsolate(),
-                        "Last requestKeyLock() has not finished yet."));
+                        "Last requestKeyboardLock() has not finished yet."));
   }
 
   if (!EnsureServiceConnected()) {
       return ScriptPromise::Reject(
           state, V8String(state->GetIsolate(), "Current frame is detached."));
   }
 
   request_keylock_resolver_ = ScriptPromiseResolver::Create(state);
-  service_->RequestKeyLock(
+  service_->RequestKeyboardLock(
       keycodes,
       ConvertToBaseCallback(WTF::Bind(
           &NavigatorKeyboardLock::LockRequestFinished, WrapPersistent(this))));
   return request_keylock_resolver_->Promise();
 }
 
-void NavigatorKeyboardLock::cancelKeyLock() {
+void NavigatorKeyboardLock::cancelKeyboardLock() {
   if (!EnsureServiceConnected()) {
     // Current frame is detached.
     return;
   }
 
-  service_->CancelKeyLock();
+  service_->CancelKeyboardLock();
 }
 
 // static
-void NavigatorKeyboardLock::cancelKeyLock(Navigator& navigator) {
-  NavigatorKeyboardLock::From(navigator).cancelKeyLock();
+void NavigatorKeyboardLock::cancelKeyboardLock(Navigator& navigator) {
+  NavigatorKeyboardLock::From(navigator).cancelKeyboardLock();
 }
 
 bool NavigatorKeyboardLock::EnsureServiceConnected() {
   if (!service_) {
     LocalFrame* frame = GetSupplementable()->GetFrame();
     if (!frame) {
       return false;
     }
     frame->GetInterfaceProvider()->GetInterface(mojo::MakeRequest(&service_));
   }
 
   DCHECK(service_);
   return true;
 }
 
-void NavigatorKeyboardLock::LockRequestFinished(bool allowed,
-                                                const String& reason) {
+void NavigatorKeyboardLock::LockRequestFinished(
+    mojom::KeyboardLockRequestResult result) {
   DCHECK(request_keylock_resolver_);
   // TODO(zijiehe): Reject with a DOMException once it has been defined in the
   // spec.
-  if (allowed)
+  if (result == mojom::KeyboardLockRequestResult::SUCCESS)
     request_keylock_resolver_->Resolve();
   else
-    request_keylock_resolver_->Reject(reason);
+    request_keylock_resolver_->Reject();
   request_keylock_resolver_ = nullptr;
 }
 
 // static
 const char* NavigatorKeyboardLock::SupplementName() {
   return "NavigatorKeyboardLock";
 }
 
 DEFINE_TRACE(NavigatorKeyboardLock) {
   visitor->Trace(request_keylock_resolver_);
   Supplement<Navigator>::Trace(visitor);
 }
 
 }  // namespace blink