[System-Keyboard-Lock] Forward navigator functions to RenderFrameHost

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"
+#include "platform/heap/Persistent.h"
+#include "platform/wtf/Assertions.h"
+#include "platform/wtf/Functional.h"
+#include "public/platform/InterfaceProvider.h"
+
+namespace blink {
+
+NavigatorKeyboardLock::NavigatorKeyboardLock(Navigator& navigator)
+    : Supplement<Navigator>(navigator) {}
+
+NavigatorKeyboardLock& NavigatorKeyboardLock::From(Navigator& navigator) {
+  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(
+    ScriptState* state,
+    Navigator& navigator,
+    const Vector<String>& keycodes) {
+  return NavigatorKeyboardLock::From(navigator).requestKeyLock(state, keycodes);
+}
+
+// static
+ScriptPromise NavigatorKeyboardLock::requestKeyLock(ScriptState* state,
+                                                    Navigator& navigator) {
+  return NavigatorKeyboardLock::requestKeyLock(state, navigator,
+                                               Vector<String>());
+}
+
+ScriptPromise NavigatorKeyboardLock::requestKeyLock(
+    ScriptState* state,
+    const Vector<String>& keycodes) {
+  DCHECK(state);
+  if (request_keylock_resolver_) {
+    return ScriptPromise::Reject(
+        state, V8String(state->GetIsolate(),
+                        "Last requestKeyLock() has not finished yet."));
+  }
+
+  String error_message;
+  if (!EnsureServiceConnected(&error_message)) {
+    // TODO(zijiehe): Reject with a DOMException once it has been defined in the
+    // spec.
+    return ScriptPromise::Reject(state,
+                                 V8String(state->GetIsolate(), error_message));
+  }
+
+  request_keylock_resolver_ = ScriptPromiseResolver::Create(state);
+  service_->RequestKeyLock(
+      keycodes,
+      ConvertToBaseCallback(WTF::Bind(
+          &NavigatorKeyboardLock::LockRequestFinished, WrapPersistent(this))));
+  return request_keylock_resolver_->Promise();
+}
+
+void NavigatorKeyboardLock::cancelKeyLock() {
+  if (!EnsureServiceConnected(nullptr))
+    return;
+
+  service_->CancelKeyLock();
+}
+
+// static
+void NavigatorKeyboardLock::cancelKeyLock(Navigator& navigator) {
+  NavigatorKeyboardLock::From(navigator).cancelKeyLock();
+}
+
+bool NavigatorKeyboardLock::EnsureServiceConnected(String* error_message) {
+  if (!service_) {
+    LocalFrame* frame = GetSupplementable()->GetFrame();
+    if (!frame) {
+      if (error_message) {
+        *error_message = String::FromUTF8("Current frame is detached.");

[dcheng, 2017/04/17 23:07:52]

Nit: I think it's relatively rare to see FromUTF8() used; most callsites just
use the implicit String(const char*) constructor.

[Hzj_jie, 2017/04/18 02:26:08]

Done.

+      }
+      return false;
+    }
+    frame->GetInterfaceProvider()->GetInterface(mojo::MakeRequest(&service_));
+  }
+
+  if (!service_.get()) {
+    if (error_message) {
+      *error_message = String::FromUTF8("Browser is not connecting.");
+    }
+    return false;
+  }
+
+  return true;
+}
+
+void NavigatorKeyboardLock::LockRequestFinished(bool allowed,
+                                                const String& reason) {
+  DCHECK(request_keylock_resolver_);
+  // TODO(zijiehe): Reject with a DOMException once it has been defined in the
+  // spec.
+  if (allowed)
+    request_keylock_resolver_->Resolve();
+  else
+    request_keylock_resolver_->Reject(reason);
+  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