Implementation for chrome.certificateProvider.requestPin/stopPinRequest

chrome/browser/chromeos/certificate_provider/pin_dialog_manager.cc

+// Copyright 2016 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 "chrome/browser/chromeos/certificate_provider/pin_dialog_manager.h"
+
+#include "ash/shell.h"
+#include "base/strings/string16.h"
+#include "chrome/browser/chromeos/login/ui/login_display_host.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "ui/aura/window.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/views/window/dialog_client_view.h"
+#include "ui/views/window/dialog_delegate.h"
+
+namespace {
+
+gfx::NativeWindow GetBrowserParentWindow() {
+  if (chromeos::LoginDisplayHost::default_host()) {
+    return chromeos::LoginDisplayHost::default_host()->GetNativeWindow();
+  }
+
+  Browser* browser =
+      chrome::FindTabbedBrowser(ProfileManager::GetPrimaryUserProfile(), true);

[Devlin, 2016/10/20 21:20:44]

GetPrimaryUserProfile sounds like it might not be the profile that triggered
this flow, which would mean we use the wrong browser here.  Is that possible? 
Should we be using something else?

[igorcov, 2016/10/25 16:38:35]

The code is the same as the one used in wifi dialog (see wifi_config_view for
details)
which is available in the same places as we need for our dialog.

+  if (browser) {
+    return browser->window()->GetNativeWindow();
+  }
+
+  return nullptr;
+}
+
+}  // namespace
+
+namespace chromeos {
+
+// Define timeout for issued sign_request_id.
+const int SIGN_REQUEST_ID_TIMEOUT_MINS = 10;
+
+PinDialogManager::PinDialogManager() : weak_factory_(this) {}
+
+PinDialogManager::~PinDialogManager() {
+  // Close the active dialog if present to avoid leaking callbacks.
+  if (active_pin_dialog_) {
+    CloseDialog(active_dialog_extension_id_);
+  }
+}
+
+void PinDialogManager::AddSignRequestId(const std::string& extension_id,
+                                        int sign_request_id) {
+  ExtensionNameRequestIdPair key(extension_id, sign_request_id);
+  // Cache the ID with current timestamp.
+  base::Time current_time = base::Time::Now();
+  sign_request_times_[key] = current_time;
+}
+
+PinDialogManager::RequestPinResponse PinDialogManager::ShowPinDialog(
+    const std::string& extension_id,
+    const std::string& extension_name,
+    int sign_request_id,
+    RequestPinView::RequestPinCodeType code_type,
+    RequestPinView::RequestPinErrorType error_type,
+    int attempts_left,
+    const RequestPinView::RequestPinCallback& callback) {
+  bool accept_input = (attempts_left != 0);
+  // If active dialog exists already, we need to make sure it belongs to the
+  // same extension and the user submitted some input.
+  if (active_pin_dialog_ != nullptr) {
+    DCHECK(!active_dialog_extension_id_.empty());
+    if (extension_id != active_dialog_extension_id_) {
+      return OTHER_FLOW_IN_PROGRESS;
+    }
+
+    // Extension requests a PIN without having received any input from its
+    // previous request. Reject the new request.
+    if (!active_pin_dialog_->IsLocked()) {
+      return DIALOG_DISPLAYED_ALREADY;
+    }
+
+    // Set the new callback to be used by the view.
+    active_pin_dialog_->SetCallback(callback);
+    active_pin_dialog_->SetDialogParameters(code_type, error_type,
+                                            attempts_left, accept_input);
+    active_pin_dialog_->GetDialogClientView()->UpdateDialogButtons();
+    return SUCCESS;
+  }
+
+  // Check the validity of sign_request_id
+  ExtensionNameRequestIdPair key(extension_id, sign_request_id);
+  if (sign_request_times_.find(key) == sign_request_times_.end()) {
+    return INVALID_ID;
+  }
+
+  base::Time current_time = base::Time::Now();
+  if ((current_time - sign_request_times_[key]).InMinutes() >
+      SIGN_REQUEST_ID_TIMEOUT_MINS) {
+    return INVALID_ID;
+  }
+
+  active_dialog_extension_id_ = extension_id;
+  active_pin_dialog_ = new RequestPinView(extension_name, code_type,
+                                          attempts_left, callback, this);
+
+  gfx::NativeWindow parent = GetBrowserParentWindow();
+  gfx::NativeWindow context =
+      parent ? nullptr : ash::Shell::GetPrimaryRootWindow();
+  active_window_ = views::DialogDelegate::CreateDialogWidget(active_pin_dialog_,
+                                                             context, parent);
+  active_window_->Show();
+
+  return SUCCESS;
+}
+
+void PinDialogManager::OnPinDialogInput() {
+  last_response_closed_[active_dialog_extension_id_] = false;
+}
+
+void PinDialogManager::OnPinDialogClosed() {
+  last_response_closed_[active_dialog_extension_id_] = true;
+  // |active_pin_dialog_| is managed by |active_window_|. This local copy of
+  // the pointer is reset here to allow a new dialog to be created when a new
+  // request comes.
+  active_pin_dialog_ = nullptr;
+}
+
+bool PinDialogManager::UpdatePinDialog(
+    const std::string& extension_id,
+    RequestPinView::RequestPinErrorType error_type,
+    bool accept_input,
+    const RequestPinView::RequestPinCallback& callback) {
+  if (active_pin_dialog_ == nullptr ||
+      extension_id != active_dialog_extension_id_ ||
+      !active_pin_dialog_->IsLocked()) {
+    return false;
+  }
+
+  active_pin_dialog_->SetCallback(callback);
+  active_pin_dialog_->SetDialogParameters(
+      RequestPinView::RequestPinCodeType::UNCHANGED, error_type, -1,
+      accept_input);
+  active_pin_dialog_->GetDialogClientView()->UpdateDialogButtons();
+  return true;
+}
+
+bool PinDialogManager::LastPinDialogClosed(const std::string& extension_id) {
+  return last_response_closed_[extension_id];
+}
+
+bool PinDialogManager::CloseDialog(const std::string& extension_id) {
+  if (extension_id != active_dialog_extension_id_ ||
+      active_pin_dialog_ == nullptr) {
+    LOG(ERROR) << "StopPinRequest called by unexpected extension: "
+               << extension_id;
+    return false;
+  }
+
+  // Close the window. |active_pin_dialog_| gets deleted inside Close().
+  active_window_->Close();
+  active_pin_dialog_ = nullptr;
+
+  return true;
+}
+
+void PinDialogManager::ExtensionUnloaded(const std::string& extension_id) {
+  if (active_pin_dialog_ && active_dialog_extension_id_ == extension_id) {
+    CloseDialog(extension_id);
+  }
+
+  last_response_closed_[extension_id] = false;
+
+  for (auto it = sign_request_times_.cbegin();
+       it != sign_request_times_.cend();) {
+    if (it->first.first == extension_id) {
+      sign_request_times_.erase(it++);
+    } else {
+      ++it;
+    }
+  }
+}
+
+}  // namespace chromeos