[Media Router] Wiring for searching route providers for new sinks.

chrome/browser/ui/webui/media_router/media_router_webui_message_handler.cc

 // Copyright 2015 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/media_router/media_router_webui_message_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/user_metrics.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_router_metrics.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/media_router/media_router_ui.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/web_ui.h"
@@ skipping 29 matching lines @@
 const char kReportFilter[] = "reportFilter";
 const char kReportInitialAction[] = "reportInitialAction";
 const char kReportInitialState[] = "reportInitialState";
 const char kReportNavigateToView[] = "reportNavigateToView";
 const char kReportRouteCreationOutcome[] = "reportRouteCreationOutcome";
 const char kReportRouteCreation[] = "reportRouteCreation";
 const char kReportSelectedCastMode[] = "reportSelectedCastMode";
 const char kReportSinkCount[] = "reportSinkCount";
 const char kReportTimeToClickSink[] = "reportTimeToClickSink";
 const char kReportTimeToInitialActionClose[] = "reportTimeToInitialActionClose";
+const char kSearchSinksAndCreateRoute[] = "searchSinksAndCreateRoute";
 const char kOnInitialDataReceived[] = "onInitialDataReceived";
 
 // JS function names.
 const char kSetInitialData[] = "media_router.ui.setInitialData";
 const char kOnCreateRouteResponseReceived[] =
     "media_router.ui.onCreateRouteResponseReceived";
+const char kReceiveSearchResult[] = "media_router.ui.receiveSearchResult";
 const char kSetFirstRunFlowData[] = "media_router.ui.setFirstRunFlowData";
 const char kSetIssue[] = "media_router.ui.setIssue";
 const char kSetSinkListAndIdentity[] = "media_router.ui.setSinkListAndIdentity";
 const char kSetRouteList[] = "media_router.ui.setRouteList";
 const char kSetCastModeList[] = "media_router.ui.setCastModeList";
 const char kUpdateMaxHeight[] = "media_router.ui.updateMaxHeight";
 const char kWindowOpen[] = "window.open";
 
 std::unique_ptr<base::DictionaryValue> SinksAndIdentityToValue(
     const std::vector<MediaSinkWithCastModes>& sinks,
@@ skipping 36 matching lines @@
       show_email = true;
       if (!domain.empty() && domain != user_domain)
         show_domain = true;
     }
 
     int cast_mode_bits = 0;
     for (MediaCastMode cast_mode : sink_with_cast_modes.cast_modes)
       cast_mode_bits |= cast_mode;
 
     sink_val->SetInteger("castModes", cast_mode_bits);
+    sink_val->SetBoolean(
+        "isPseudoSink",
+        base::StartsWith(sink.id(), "pseudo:", base::CompareCase::SENSITIVE));
     sinks_val->Append(sink_val.release());
   }
 
   sink_list_and_identity->Set("sinks", sinks_val.release());
   sink_list_and_identity->SetBoolean("showEmail", show_email);
   sink_list_and_identity->SetBoolean("showDomain", show_domain);
   return sink_list_and_identity;
 }
 
 std::unique_ptr<base::DictionaryValue> RouteToValue(
@@ skipping 148 matching lines @@
         base::StringValue(sink_id), *route_value,
         base::FundamentalValue(route->for_display()));
   } else {
     web_ui()->CallJavascriptFunction(kOnCreateRouteResponseReceived,
                                      base::StringValue(sink_id),
                                      *base::Value::CreateNullValue(),
                                      base::FundamentalValue(false));
   }
 }
 
+void MediaRouterWebUIMessageHandler::ReturnSearchResult(
+    const std::string& sink_id) {
+  DVLOG(2) << "ReturnSearchResult";
+  web_ui()->CallJavascriptFunction(kReceiveSearchResult,
+                                   base::StringValue(sink_id));
+}
+
 void MediaRouterWebUIMessageHandler::UpdateIssue(const Issue* issue) {
   DVLOG(2) << "UpdateIssue";
   web_ui()->CallJavascriptFunction(kSetIssue,
       issue ? *IssueToValue(*issue) : *base::Value::CreateNullValue());
 }
 
 void MediaRouterWebUIMessageHandler::UpdateMaxDialogHeight(int height) {
   DVLOG(2) << "UpdateMaxDialogHeight";
   web_ui()->CallJavascriptFunction(kUpdateMaxHeight,
                                    base::FundamentalValue(height));
@@ skipping 71 matching lines @@
   web_ui()->RegisterMessageCallback(
       kReportTimeToClickSink,
       base::Bind(&MediaRouterWebUIMessageHandler::OnReportTimeToClickSink,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kReportTimeToInitialActionClose,
       base::Bind(
           &MediaRouterWebUIMessageHandler::OnReportTimeToInitialActionClose,
           base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      kSearchSinksAndCreateRoute,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnSearchSinksAndCreateRoute,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       kOnInitialDataReceived,
       base::Bind(&MediaRouterWebUIMessageHandler::OnInitialDataReceived,
                  base::Unretained(this)));
 }
 
 void MediaRouterWebUIMessageHandler::OnRequestInitialData(
     const base::ListValue* args) {
   DVLOG(1) << "OnRequestInitialData";
   media_router_ui_->OnUIInitiallyLoaded();
   base::DictionaryValue initial_data;
@@ skipping 331 matching lines @@
   DVLOG(1) << "OnReportTimeToInitialActionClose";
   double time_to_close;
   if (!args->GetDouble(0, &time_to_close)) {
     VLOG(0) << "Unable to extract args.";
     return;
   }
   UMA_HISTOGRAM_TIMES("MediaRouter.Ui.Action.CloseLatency",
                       base::TimeDelta::FromMillisecondsD(time_to_close));
 }
 
+void MediaRouterWebUIMessageHandler::OnSearchSinksAndCreateRoute(
+    const base::ListValue* args) {
+  DVLOG(1) << "OnSearchSinksAndCreateRoute";
+  const base::DictionaryValue* args_dict = nullptr;
+  std::string sink_id;
+  std::string search_criteria;
+  std::string domain;
+  int cast_mode_num = -1;
+  if (!args->GetDictionary(0, &args_dict) ||
+      !args_dict->GetString("sinkId", &sink_id) ||
+      !args_dict->GetString("searchCriteria", &search_criteria) ||
+      !args_dict->GetString("domain", &domain) ||
+      !args_dict->GetInteger("selectedCastMode", &cast_mode_num)) {
+    DVLOG(1) << "Unable to extract args";
+    return;
+  }
+
+  if (search_criteria.empty()) {
+    DVLOG(1) << "Media Router UI did not provide valid search criteria. "
+                "Aborting.";
+    return;
+  }
+
+  if (!IsValidCastModeNum(cast_mode_num)) {
+    DVLOG(1) << "Invalid cast mode: " << cast_mode_num << ". Aborting.";
+    return;
+  }
+
+  // TODO(btolsch): Check result and add an issue if it failed.
+  media_router_ui_->SearchSinksAndCreateRoute(
+      sink_id, search_criteria, domain,
+      static_cast<MediaCastMode>(cast_mode_num));
+}
+
 void MediaRouterWebUIMessageHandler::OnInitialDataReceived(
     const base::ListValue* args) {
   DVLOG(1) << "OnInitialDataReceived";
   media_router_ui_->OnUIInitialDataReceived();
   MaybeUpdateFirstRunFlowData();
 }
 
 bool MediaRouterWebUIMessageHandler::ActOnIssueType(
     const IssueAction::Type& action_type,
     const base::DictionaryValue* args) {
@@ skipping 72 matching lines @@
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
   return AccountInfo();
 }
 
 void MediaRouterWebUIMessageHandler::SetWebUIForTest(content::WebUI* web_ui) {
   set_web_ui(web_ui);
 }
 
 }  // namespace media_router