Move {Resolve|Reject}JavascriptCallback helpers in WebUIMessageHandler.

chrome/browser/ui/webui/signin/signin_supervised_user_import_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/signin/signin_supervised_user_import_handler.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 62 matching lines @@
   web_ui()->RegisterMessageCallback("openUrlInLastActiveProfileBrowser",
       base::Bind(
           &SigninSupervisedUserImportHandler::OpenUrlInLastActiveProfileBrowser,
           base::Unretained(this)));
 }
 
 void SigninSupervisedUserImportHandler::AssignWebUICallbackId(
     const base::ListValue* args) {
   CHECK_LE(1U, args->GetSize());
   CHECK(webui_callback_id_.empty());
   CHECK(args->GetString(0, &webui_callback_id_));

[Dan Beam, 2016/06/03 19:03:36]

nit: maybe AllowJavascript() here?

[dpapad, 2016/06/03 19:41:14]

Done.

 }
 
 void SigninSupervisedUserImportHandler::OpenUrlInLastActiveProfileBrowser(
     const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
   std::string url;
   bool success = args->GetString(0, &url);
   DCHECK(success);
   content::OpenURLParams params(GURL(url),
                                 content::Referrer(),
@@ skipping 32 matching lines @@
   AssignWebUICallbackId(args);
 
   base::FilePath custodian_profile_path;
   const base::Value* profile_path_value;
   bool success = args->Get(1, &profile_path_value);
   DCHECK(success);
   success = base::GetValueAsFilePath(*profile_path_value,
                                      &custodian_profile_path);
   DCHECK(success);
 
+  AllowJavascript();
   // Load custodian profile.
   g_browser_process->profile_manager()->CreateProfileAsync(
       custodian_profile_path,
       base::Bind(
           &SigninSupervisedUserImportHandler::LoadCustodianProfileCallback,
           weak_ptr_factory_.GetWeakPtr()),
       base::string16(), std::string(), std::string());
 }
 
 void SigninSupervisedUserImportHandler::LoadCustodianProfileCallback(
@@ skipping 37 matching lines @@
     case Profile::CREATE_STATUS_REMOTE_FAIL:
     case Profile::MAX_CREATE_STATUS: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void SigninSupervisedUserImportHandler::RejectCallback(
     const base::string16& error) {
-  web_ui()->CallJavascriptFunction("cr.webUIResponse",
+  RejectJavascriptCallback(
       base::StringValue(webui_callback_id_),
-      base::FundamentalValue(false),
       base::StringValue(error));
   webui_callback_id_.clear();
 }
 
 base::string16 SigninSupervisedUserImportHandler::GetLocalErorrMessage() const {
   return l10n_util::GetStringUTF16(
       IDS_LEGACY_SUPERVISED_USER_IMPORT_LOCAL_ERROR);
 }
 
 base::string16 SigninSupervisedUserImportHandler::GetAuthErorrMessage() const {
@@ skipping 54 matching lines @@
             profiles::GetDefaultAvatarIconUrl(avatar_index);
     supervised_user->SetString("iconURL", avatar_url);
     bool on_current_device =
         supervised_user_ids.find(it.key()) != supervised_user_ids.end();
     supervised_user->SetBoolean("onCurrentDevice", on_current_device);
 
     supervised_users.Append(supervised_user);
   }
 
   // Resolve callback with response.
-  web_ui()->CallJavascriptFunction("cr.webUIResponse",
+  ResolveJavascriptCallback(
       base::StringValue(webui_callback_id_),
-      base::FundamentalValue(true),
       supervised_users);
   webui_callback_id_.clear();
 }
 
 bool SigninSupervisedUserImportHandler::IsAccountConnected(
       Profile* profile) const {
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   return signin_manager && signin_manager->IsAuthenticated();
 }
 
 bool SigninSupervisedUserImportHandler::HasAuthError(Profile* profile) const {
   SigninErrorController* error_controller =
       SigninErrorControllerFactory::GetForProfile(profile);
   if (!error_controller)
     return true;
 
   GoogleServiceAuthError::State state = error_controller->auth_error().state();
   return state != GoogleServiceAuthError::NONE;
 }