arc: enable use_new_wrapper_types for intent_helper.mojom

chrome/browser/chromeos/arc/intent_helper/arc_external_protocol_dialog.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/arc/intent_helper/arc_external_protocol_dialog.h"
 
 #include <memory>
 #include <utility>

[Luis Héctor Chávez, 2016/11/16 03:22:02]

nit: remove utility, vector

[Yusuke Sato, 2016/11/16 06:10:21]

Done.

 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/chromeos/arc/intent_helper/arc_navigation_throttle.h"
 #include "chrome/browser/chromeos/external_protocol_dialog.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
@@ skipping 74 matching lines @@
 
   instance->HandleUrl(url_and_package.first.spec(), url_and_package.second);
   CloseTabIfNeeded(render_process_host_id, routing_id);
 }
 
 // A helper function called by GetAction().
 GetActionResult GetActionInternal(
     const GURL& original_url,
     const mojom::IntentHandlerInfoPtr& handler,
     std::pair<GURL, std::string>* out_url_and_package) {
-  if (!handler->fallback_url.is_null()) {
-    *out_url_and_package = std::make_pair(GURL(handler->fallback_url.get()),
-                                          handler->package_name.get());
+  if (handler->fallback_url.has_value()) {
+    *out_url_and_package =
+        std::make_pair(GURL(*handler->fallback_url), handler->package_name);
     if (ArcIntentHelperBridge::IsIntentHelperPackage(handler->package_name)) {
       // Since |package_name| is "Chrome", and |fallback_url| is not null, the
       // URL must be either http or https. Check it just in case, and if not,
       // fallback to HANDLE_URL_IN_ARC;
       if (out_url_and_package->first.SchemeIsHTTPOrHTTPS())
         return GetActionResult::OPEN_URL_IN_CHROME;
 
       LOG(WARNING) << "Failed to handle " << out_url_and_package->first
                    << " in Chrome. Falling back to ARC...";
     }
     // |fallback_url| which Chrome doesn't support is passed (e.g. market:).
     return GetActionResult::HANDLE_URL_IN_ARC;
   }
 
   // Unlike |handler->fallback_url|, the |original_url| should always be handled
   // in ARC since it's external to Chrome.
-  *out_url_and_package =
-      std::make_pair(original_url, handler->package_name.get());
+  *out_url_and_package = std::make_pair(original_url, handler->package_name);
   return GetActionResult::HANDLE_URL_IN_ARC;
 }
 
 // Gets an action that should be done when ARC has the |handlers| for the
 // |original_url| and the user selects |selected_app_index|. When the user
 // hasn't selected any app, |selected_app_index| must be set to
 // |handlers.size()|.
 //
 // When the returned action is either OPEN_URL_IN_CHROME or HANDLE_URL_IN_ARC,
 // |out_url_and_package| is filled accordingly.
 GetActionResult GetAction(
     const GURL& original_url,
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers,
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers,
     size_t selected_app_index,
     std::pair<GURL, std::string>* out_url_and_package) {
   DCHECK(out_url_and_package);
   if (!handlers.size())
     return GetActionResult::SHOW_CHROME_OS_DIALOG;  // no apps found.
 
   if (selected_app_index == handlers.size()) {
     // The user hasn't made the selection yet.
 
     // If |handlers| has only one element and its package is "Chrome", open
@@ skipping 23 matching lines @@
   // The user has already made the selection. Decide how to open it, either in
   // Chrome or ARC.
   return GetActionInternal(original_url, handlers[selected_app_index],
                            out_url_and_package);
 }
 
 // Handles |url| if possible. Returns true if it is actually handled.
 bool HandleUrl(int render_process_host_id,
                int routing_id,
                const GURL& url,
-               const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers,
+               const std::vector<mojom::IntentHandlerInfoPtr>& handlers,
                size_t selected_app_index,
                GetActionResult* out_result) {
   std::pair<GURL, std::string> url_and_package;
   const GetActionResult result =
       GetAction(url, handlers, selected_app_index, &url_and_package);
   if (out_result)
     *out_result = result;
 
   switch (result) {
     case GetActionResult::SHOW_CHROME_OS_DIALOG:
       ShowFallbackExternalProtocolDialog(render_process_host_id, routing_id,
                                          url);
       return true;
     case GetActionResult::OPEN_URL_IN_CHROME:
       OpenUrlInChrome(render_process_host_id, routing_id,
                       url_and_package.first);
       return true;
     case GetActionResult::HANDLE_URL_IN_ARC:
       HandleUrlInArc(render_process_host_id, routing_id, url_and_package);
       return true;
     case GetActionResult::ASK_USER:
       break;
   }
   return false;
 }
 
 // Returns a fallback http(s) in |handlers| which Chrome can handle. Returns
 // an empty GURL if none found.
 GURL GetUrlToNavigateOnDeactivate(
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers) {
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers) {
   const GURL empty_url;
   for (size_t i = 0; i < handlers.size(); ++i) {
     std::pair<GURL, std::string> url_and_package;
     if (GetActionInternal(empty_url, handlers[i], &url_and_package) ==
         GetActionResult::OPEN_URL_IN_CHROME) {
       DCHECK(url_and_package.first.SchemeIsHTTPOrHTTPS());
       return url_and_package.first;
     }
   }
   return empty_url;  // nothing found.
 }
 
 // Called when the dialog is just deactivated without pressing one of the
 // buttons.
 void OnIntentPickerDialogDeactivated(
     int render_process_host_id,
     int routing_id,
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers) {
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers) {
   const GURL url_to_open_in_chrome = GetUrlToNavigateOnDeactivate(handlers);
   if (url_to_open_in_chrome.is_empty())
     CloseTabIfNeeded(render_process_host_id, routing_id);
   else
     OpenUrlInChrome(render_process_host_id, routing_id, url_to_open_in_chrome);
 }
 
 // Called when the dialog is closed. Note that once we show the UI, we should
 // never show the Chrome OS' fallback dialog.
 void OnIntentPickerClosed(int render_process_host_id,
                           int routing_id,
                           const GURL& url,
-                          mojo::Array<mojom::IntentHandlerInfoPtr> handlers,
+                          std::vector<mojom::IntentHandlerInfoPtr> handlers,
                           const std::string& selected_app_package,
                           ArcNavigationThrottle::CloseReason close_reason) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // If the user selected an app to continue the navigation, confirm that the
   // |package_name| matches a valid option and return the index.
   const size_t selected_app_index =
       ArcNavigationThrottle::GetAppIndex(handlers, selected_app_package);
   // Make sure that the instance at least supports HandleUrl.
   auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
@@ skipping 47 matching lines @@
       ArcNavigationThrottle::GetDestinationPlatform(selected_app_package,
                                                     close_reason);
   ArcNavigationThrottle::RecordUma(close_reason, platform);
 }
 
 // Called when ARC returned activity icons for the |handlers|.
 void OnAppIconsReceived(
     int render_process_host_id,
     int routing_id,
     const GURL& url,
-    mojo::Array<mojom::IntentHandlerInfoPtr> handlers,
+    std::vector<mojom::IntentHandlerInfoPtr> handlers,
     std::unique_ptr<ActivityIconLoader::ActivityToIconsMap> icons) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   using AppInfo = arc::ArcNavigationThrottle::AppInfo;
   std::vector<AppInfo> app_info;
 
   for (const auto& handler : handlers) {
     const ActivityIconLoader::ActivityName activity(handler->package_name,
                                                     handler->activity_name);
     const auto it = icons->find(activity);
     app_info.emplace_back(
         AppInfo(it != icons->end() ? it->second.icon20 : gfx::Image(),
                 handler->package_name, handler->name));
   }
 
   auto show_bubble_cb = base::Bind(ShowIntentPickerBubble());
   WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_host_id, routing_id);
   show_bubble_cb.Run(web_contents, app_info,
                      base::Bind(OnIntentPickerClosed, render_process_host_id,
                                 routing_id, url, base::Passed(&handlers)));
 }
 
 // Called when ARC returned a handler list for the |url|.
 void OnUrlHandlerList(int render_process_host_id,
                       int routing_id,
                       const GURL& url,
-                      mojo::Array<mojom::IntentHandlerInfoPtr> handlers) {
+                      std::vector<mojom::IntentHandlerInfoPtr> handlers) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
       "HandleUrl", kMinVersionForHandleUrl);
   scoped_refptr<ActivityIconLoader> icon_loader = GetIconLoader();
 
   if (!instance || !icon_loader) {
     // ARC is not running anymore. Show the Chrome OS dialog.
     ShowFallbackExternalProtocolDialog(render_process_host_id, routing_id, url);
     return;
@@ skipping 78 matching lines @@
       base::Bind(OnUrlHandlerList, render_process_host_id, routing_id, url));
   return true;
 }
 
 bool ShouldIgnoreNavigationForTesting(ui::PageTransition page_transition) {
   return ShouldIgnoreNavigation(page_transition);
 }
 
 GetActionResult GetActionForTesting(
     const GURL& original_url,
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers,
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers,
     size_t selected_app_index,
     std::pair<GURL, std::string>* out_url_and_package) {
   return GetAction(original_url, handlers, selected_app_index,
                    out_url_and_package);
 }
 
 GURL GetUrlToNavigateOnDeactivateForTesting(
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers) {
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers) {
   return GetUrlToNavigateOnDeactivate(handlers);
 }
 
 }  // namespace arc