Determine the Win10-specific Welcome page variant to display

chrome/browser/ui/webui/welcome_win10_handler.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/ui/webui/welcome_win10_handler.h"
 
-#include <string>
-
 #include "base/bind.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/common/url_constants.h"
+#include "chrome/grit/generated_resources.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "url/gurl.h"
 
-WelcomeWin10Handler::WelcomeWin10Handler() = default;
+WelcomeWin10Handler::WelcomeWin10Handler() {
+  // The check is started as early as possible because waiting for the page to
+  // be fully loaded is unnecessarily wasting time.
+  StartIsPinnedToTaskbarCheck();
+}
 
 WelcomeWin10Handler::~WelcomeWin10Handler() = default;
 
-// Override from WebUIMessageHandler.
 void WelcomeWin10Handler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "handleSetDefaultBrowser",
       base::Bind(&WelcomeWin10Handler::HandleSetDefaultBrowser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "handleContinue",
       base::Bind(&WelcomeWin10Handler::HandleContinue, base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "getPinnedToTaskbarState",
+      base::Bind(&WelcomeWin10Handler::HandleGetPinnedToTaskbarState,
+                 base::Unretained(this)));
+}
+
+void WelcomeWin10Handler::HandleGetPinnedToTaskbarState(
+    const base::ListValue* args) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  AllowJavascript();
+
+  CHECK_EQ(1U, args->GetSize());

[Peter Kasting, 2016/11/02 00:03:21]

Nit: Normally CHECK is only for temporary debugging (to see what assertion is
failing in the field) or for security-critical issues where if an assertion is
violated we'll have an exploitable hole.

If these conditions cannot be violated (because you know the caller guarantees
them), then you should probably be using DCHECK instead.  If they can be (with
unvalidated input from the user or something), then you should be checking them
conditionally and handling failure.

[michaelpg, 2016/11/02 01:04:45]

+dbeam

These CHECKs are very common in MD Settings WebUI handlers, for some reason.

https://cs.chromium.org/search/?q=%5Cscheck_eq%5C(%5Cd.?,%5Csargs+file:webui&...

[Patrick Monette, 2016/11/02 20:48:42]

I had effectively just copied code in other MD settings handlers. I switched to
DCHECK.

+  // Save the callback id so that the result can be sent back when it is
+  // available.
+  CHECK(args->GetString(0, &pinned_state_callback_id_));

[Peter Kasting, 2016/11/02 00:03:21]

Nit: While technically this is safe because CHECK always runs, I suggest not
doing work with side effects in a CHECK.  It's easy to change it to a DCHECK
later (e.g. due to my above comment) and not realize that now the behavior
differs between builds.

[Patrick Monette, 2016/11/02 20:48:42]

Done.

+
+  // Send back the result if it is already available.
+  if (pinned_state_result_) {
+    SendPinnedToTaskbarStateResult();
+    return;
+  }
+
+  // Only wait for a small amount of time for the result. If the timer fires,
+  // it will be assumed that Chrome is pinned to the taskbar.
+  constexpr base::TimeDelta kPinnedToTaskbarTimeout =
+      base::TimeDelta::FromMilliseconds(200);
+  timer_.Start(FROM_HERE, kPinnedToTaskbarTimeout,
+               base::Bind(&WelcomeWin10Handler::OnIsPinnedToTaskbarDetermined,
+                          base::Unretained(this), true));
 }
 
 void WelcomeWin10Handler::HandleSetDefaultBrowser(const base::ListValue* args) {
   // The worker owns itself.
   (new shell_integration::DefaultBrowserWorker(
        shell_integration::DefaultWebClientWorkerCallback()))
       ->StartSetAsDefault();
 }
 
 void WelcomeWin10Handler::HandleContinue(const base::ListValue* args) {
   web_ui()->GetWebContents()->GetController().LoadURL(
       GURL(chrome::kChromeUINewTabURL), content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_LINK, std::string());
 }
+
+void WelcomeWin10Handler::StartIsPinnedToTaskbarCheck() {
+  // Start the utility process that will handle the IsPinnedToTaskbar() call.
+  client_.reset(new content::UtilityProcessMojoClient<mojom::ShellHandler>(

[Peter Kasting, 2016/11/02 00:03:21]

Nit: Prefer base::MakeUnique() to raw new:

  client_ =
      base::MakeUnique<content::UtilityProcessMojoClient<mojom::ShellHandler>>(
          ...);

[Patrick Monette, 2016/11/02 20:48:42]

Done.

+      l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_SHELL_HANDLER_NAME)));
+
+  // Assume that Chrome is pinned to the taskbar if an error occurs.
+  client_->set_error_callback(
+      base::Bind(&WelcomeWin10Handler::OnIsPinnedToTaskbarDetermined,
+                 base::Unretained(this), true));
+  client_->set_disable_sandbox();
+  client_->Start();
+
+  client_->service()->IsPinnedToTaskbar(base::Bind(
+      &WelcomeWin10Handler::OnIsPinnedToTaskbarResult, base::Unretained(this)));
+}
+
+void WelcomeWin10Handler::OnIsPinnedToTaskbarResult(bool succeeded,
+                                                    bool is_pinned_to_taskbar) {
+  OnIsPinnedToTaskbarDetermined(succeeded && is_pinned_to_taskbar);
+}
+
+void WelcomeWin10Handler::OnIsPinnedToTaskbarDetermined(
+    bool is_pinned_to_taskbar) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  // Reset the client and the timer to make sure this function only gets called
+  // once.
+  client_.reset();
+  timer_.Stop();
+
+  pinned_state_result_ = is_pinned_to_taskbar;
+
+  // If the page already called getPinnedToTaskbarState(), the result can be
+  // sent back.
+  if (!pinned_state_callback_id_.empty())
+    SendPinnedToTaskbarStateResult();
+}
+
+void WelcomeWin10Handler::SendPinnedToTaskbarStateResult() {
+  ResolveJavascriptCallback(
+      base::StringValue(pinned_state_callback_id_),
+      base::FundamentalValue(pinned_state_result_.value()));
+}