Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

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"
@@ skipping 55 matching lines @@
 const char kOnCreateRouteResponseReceived[] =
     "media_router.ui.onCreateRouteResponseReceived";
 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";
 
-scoped_ptr<base::DictionaryValue> SinksAndIdentityToValue(
+std::unique_ptr<base::DictionaryValue> SinksAndIdentityToValue(
     const std::vector<MediaSinkWithCastModes>& sinks,
     const AccountInfo& account_info) {
-  scoped_ptr<base::DictionaryValue> sink_list_and_identity(
+  std::unique_ptr<base::DictionaryValue> sink_list_and_identity(
       new base::DictionaryValue);
   bool show_email = false;
   bool show_domain = false;
   std::string user_domain;
   if (account_info.IsValid()) {
     user_domain = account_info.hosted_domain;
     sink_list_and_identity->SetString("userEmail", account_info.email);
     sink_list_and_identity->SetString("userDomain", user_domain);
   }
 
-  scoped_ptr<base::ListValue> sinks_val(new base::ListValue);
+  std::unique_ptr<base::ListValue> sinks_val(new base::ListValue);
 
   for (const MediaSinkWithCastModes& sink_with_cast_modes : sinks) {
-    scoped_ptr<base::DictionaryValue> sink_val(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> sink_val(new base::DictionaryValue);
 
     const MediaSink& sink = sink_with_cast_modes.sink;
     sink_val->SetString("id", sink.id());
     sink_val->SetString("name", sink.name());
     sink_val->SetInteger("iconType", sink.icon_type());
     if (!sink.description().empty())
       sink_val->SetString("description", sink.description());
 
     if (!user_domain.empty() && !sink.domain().empty()) {
       std::string domain = sink.domain();
@@ skipping 20 matching lines @@
     sink_val->SetInteger("castModes", cast_mode_bits);
     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;
 }
 
-scoped_ptr<base::DictionaryValue> RouteToValue(
-    const MediaRoute& route, bool canJoin, const std::string& extension_id) {
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue> RouteToValue(
+    const MediaRoute& route,
+    bool canJoin,
+    const std::string& extension_id) {
+  std::unique_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
   dictionary->SetString("id", route.media_route_id());
   dictionary->SetString("sinkId", route.media_sink_id());
   dictionary->SetString("description", route.description());
   dictionary->SetBoolean("isLocal", route.is_local());
   dictionary->SetBoolean("canJoin", canJoin);
   dictionary->SetBoolean("isOffTheRecord", route.off_the_record());
 
   const std::string& custom_path = route.custom_controller_path();
   if (!custom_path.empty()) {
     std::string full_custom_controller_path = base::StringPrintf("%s://%s/%s",
         extensions::kExtensionScheme, extension_id.c_str(),
             custom_path.c_str());
     DCHECK(GURL(full_custom_controller_path).is_valid());
     dictionary->SetString("customControllerPath",
                           full_custom_controller_path);
   }
 
   return dictionary;
 }
 
-scoped_ptr<base::ListValue> RoutesToValue(
+std::unique_ptr<base::ListValue> RoutesToValue(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids,
     const std::string& extension_id) {
-  scoped_ptr<base::ListValue> value(new base::ListValue);
+  std::unique_ptr<base::ListValue> value(new base::ListValue);
 
   for (const MediaRoute& route : routes) {
     bool canJoin = ContainsValue(joinable_route_ids, route.media_route_id());
-    scoped_ptr<base::DictionaryValue> route_val(RouteToValue(route,
-        canJoin, extension_id));
+    std::unique_ptr<base::DictionaryValue> route_val(
+        RouteToValue(route, canJoin, extension_id));
     value->Append(route_val.release());
   }
 
   return value;
 }
 
-scoped_ptr<base::ListValue> CastModesToValue(const CastModeSet& cast_modes,
-                                             const std::string& source_host) {
-  scoped_ptr<base::ListValue> value(new base::ListValue);
+std::unique_ptr<base::ListValue> CastModesToValue(
+    const CastModeSet& cast_modes,
+    const std::string& source_host) {
+  std::unique_ptr<base::ListValue> value(new base::ListValue);
 
   for (const MediaCastMode& cast_mode : cast_modes) {
-    scoped_ptr<base::DictionaryValue> cast_mode_val(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> cast_mode_val(
+        new base::DictionaryValue);
     cast_mode_val->SetInteger("type", cast_mode);
     cast_mode_val->SetString(
         "description", MediaCastModeToDescription(cast_mode, source_host));
     cast_mode_val->SetString("host", source_host);
     value->Append(cast_mode_val.release());
   }
 
   return value;
 }
 
 // Returns an Issue dictionary created from |issue| that can be used in WebUI.
-scoped_ptr<base::DictionaryValue> IssueToValue(const Issue& issue) {
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue> IssueToValue(const Issue& issue) {
+  std::unique_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
   dictionary->SetString("id", issue.id());
   dictionary->SetString("title", issue.title());
   dictionary->SetString("message", issue.message());
   dictionary->SetInteger("defaultActionType", issue.default_action().type());
   if (!issue.secondary_actions().empty()) {
     dictionary->SetInteger("secondaryActionType",
                            issue.secondary_actions().begin()->type());
   }
   if (!issue.route_id().empty())
     dictionary->SetString("routeId", issue.route_id());
@@ skipping 34 matching lines @@
       media_router_ui_(media_router_ui) {
   DCHECK(media_router_ui_);
 }
 
 MediaRouterWebUIMessageHandler::~MediaRouterWebUIMessageHandler() {
 }
 
 void MediaRouterWebUIMessageHandler::UpdateSinks(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   DVLOG(2) << "UpdateSinks";
-  scoped_ptr<base::DictionaryValue> sinks_and_identity_val(
+  std::unique_ptr<base::DictionaryValue> sinks_and_identity_val(
       SinksAndIdentityToValue(sinks, GetAccountInfo()));
   web_ui()->CallJavascriptFunction(kSetSinkListAndIdentity,
                                    *sinks_and_identity_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateRoutes(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids) {
-  scoped_ptr<base::ListValue> routes_val(RoutesToValue(routes,
-      joinable_route_ids,
-      media_router_ui_->GetRouteProviderExtensionId()));
+  std::unique_ptr<base::ListValue> routes_val(
+      RoutesToValue(routes, joinable_route_ids,
+                    media_router_ui_->GetRouteProviderExtensionId()));
   web_ui()->CallJavascriptFunction(kSetRouteList, *routes_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateCastModes(
     const CastModeSet& cast_modes,
     const std::string& source_host) {
   DVLOG(2) << "UpdateCastModes";
-  scoped_ptr<base::ListValue> cast_modes_val(
+  std::unique_ptr<base::ListValue> cast_modes_val(
       CastModesToValue(cast_modes, source_host));
   web_ui()->CallJavascriptFunction(kSetCastModeList, *cast_modes_val);
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRouteResponseReceived(
     const MediaSink::Id& sink_id,
     const MediaRoute* route) {
   DVLOG(2) << "OnCreateRouteResponseReceived";
   if (route) {
-    scoped_ptr<base::DictionaryValue> route_value(RouteToValue(*route, false,
-        media_router_ui_->GetRouteProviderExtensionId()));
+    std::unique_ptr<base::DictionaryValue> route_value(RouteToValue(
+        *route, false, media_router_ui_->GetRouteProviderExtensionId()));
     web_ui()->CallJavascriptFunction(
         kOnCreateRouteResponseReceived,
         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));
   }
@@ skipping 98 matching lines @@
 void MediaRouterWebUIMessageHandler::OnRequestInitialData(
     const base::ListValue* args) {
   DVLOG(1) << "OnRequestInitialData";
   media_router_ui_->OnUIInitiallyLoaded();
   base::DictionaryValue initial_data;
 
   // "No Cast devices found?" Chromecast help center page.
   initial_data.SetString("deviceMissingUrl",
       base::StringPrintf(kHelpPageUrlPrefix, 3249268));
 
-  scoped_ptr<base::DictionaryValue> sinks_and_identity(
+  std::unique_ptr<base::DictionaryValue> sinks_and_identity(
       SinksAndIdentityToValue(media_router_ui_->sinks(), GetAccountInfo()));
   initial_data.Set("sinksAndIdentity", sinks_and_identity.release());
 
-  scoped_ptr<base::ListValue> routes(RoutesToValue(media_router_ui_->routes(),
-      media_router_ui_->joinable_route_ids(),
+  std::unique_ptr<base::ListValue> routes(RoutesToValue(
+      media_router_ui_->routes(), media_router_ui_->joinable_route_ids(),
       media_router_ui_->GetRouteProviderExtensionId()));
   initial_data.Set("routes", routes.release());
 
   const std::set<MediaCastMode> cast_modes = media_router_ui_->cast_modes();
-  scoped_ptr<base::ListValue> cast_modes_list(
-      CastModesToValue(cast_modes,
-                       media_router_ui_->GetPresentationRequestSourceName()));
+  std::unique_ptr<base::ListValue> cast_modes_list(CastModesToValue(
+      cast_modes, media_router_ui_->GetPresentationRequestSourceName()));
   initial_data.Set("castModes", cast_modes_list.release());
 
   web_ui()->CallJavascriptFunction(kSetInitialData, initial_data);
   media_router_ui_->UIInitialized();
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRoute(
     const base::ListValue* args) {
   DVLOG(1) << "OnCreateRoute";
   const base::DictionaryValue* args_dict = nullptr;
@@ skipping 318 matching lines @@
   MaybeUpdateFirstRunFlowData();
 }
 
 bool MediaRouterWebUIMessageHandler::ActOnIssueType(
     const IssueAction::Type& action_type,
     const base::DictionaryValue* args) {
   if (action_type == IssueAction::TYPE_LEARN_MORE) {
     std::string learn_more_url = GetLearnMoreUrl(args);
     if (learn_more_url.empty())
       return false;
-    scoped_ptr<base::ListValue> open_args(new base::ListValue);
+    std::unique_ptr<base::ListValue> open_args(new base::ListValue);
     open_args->AppendString(learn_more_url);
     web_ui()->CallJavascriptFunction(kWindowOpen, *open_args);
     return true;
   } else {
     // Do nothing; no other issue action types require any other action.
     return true;
   }
 }
 
 void MediaRouterWebUIMessageHandler::MaybeUpdateFirstRunFlowData() {
@@ skipping 57 matching lines @@
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
   return AccountInfo();
 }
 
 void MediaRouterWebUIMessageHandler::SetWebUIForTest(content::WebUI* web_ui) {
   set_web_ui(web_ui);
 }
 
 }  // namespace media_router