arc: enable use_new_wrapper_types for intent_helper.mojom

chrome/browser/chromeos/arc/intent_helper/arc_navigation_throttle.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_navigation_throttle.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 50 matching lines @@
   }
 
   return !net::registry_controlled_domains::SameDomainOrHost(
       current_url, previous_url,
       net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
 }
 
 // Returns true if |handlers| contain one or more apps. When this function is
 // called from OnAppCandidatesReceived, |handlers| always contain Chrome (aka
 // intent_helper), but the function doesn't treat it as an app.
-bool IsAppAvailable(const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers) {
+bool IsAppAvailable(const std::vector<mojom::IntentHandlerInfoPtr>& handlers) {
   return handlers.size() > 1 || (handlers.size() == 1 &&
                                  !ArcIntentHelperBridge::IsIntentHelperPackage(
                                      handlers[0]->package_name));
 }
 
 // Searches for a preferred app in |handlers| and returns its index. If not
 // found, returns |handlers.size()|.
 size_t FindPreferredApp(
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers,
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers,
     const GURL& url_for_logging) {
   for (size_t i = 0; i < handlers.size(); ++i) {
     if (!handlers[i]->is_preferred)
       continue;
     if (ArcIntentHelperBridge::IsIntentHelperPackage(
             handlers[i]->package_name)) {
       // If Chrome browser was selected as the preferred app, we shouldn't
       // create a throttle.
       DVLOG(1)
           << "Chrome browser is selected as the preferred app for this URL: "
@@ skipping 121 matching lines @@
       navigation_handle()->GetWebContents()->GetLastCommittedURL();
   if (last_committed_url.is_valid() && !last_committed_url.is_empty())
     return last_committed_url;
 
   return navigation_handle()->GetStartingSiteInstance()->GetSiteURL();
 }
 
 // We received the array of app candidates to handle this URL (even the Chrome
 // app is included).
 void ArcNavigationThrottle::OnAppCandidatesReceived(
-    mojo::Array<mojom::IntentHandlerInfoPtr> handlers) {
+    std::vector<mojom::IntentHandlerInfoPtr> handlers) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!IsAppAvailable(handlers)) {
     // This scenario shouldn't be accesed as ArcNavigationThrottle is created
     // iff there are ARC apps which can actually handle the given URL.
     DVLOG(1) << "There are no app candidates for this URL: "
              << navigation_handle()->GetURL();
     navigation_handle()->Resume();
     return;
   }
 
@@ skipping 21 matching lines @@
   std::vector<ActivityIconLoader::ActivityName> activities;
   for (const auto& handler : handlers)
     activities.emplace_back(handler->package_name, handler->activity_name);
   icon_loader->GetActivityIcons(
       activities,
       base::Bind(&ArcNavigationThrottle::OnAppIconsReceived,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&handlers)));
 }
 
 void ArcNavigationThrottle::OnAppIconsReceived(
-    mojo::Array<mojom::IntentHandlerInfoPtr> handlers,
+    std::vector<mojom::IntentHandlerInfoPtr> handlers,
     std::unique_ptr<ActivityIconLoader::ActivityToIconsMap> icons) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   std::vector<AppInfo> app_info;
 
   for (const auto& handler : handlers) {
     gfx::Image icon;
     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));
   }
 
   show_intent_picker_callback_.Run(
       navigation_handle()->GetWebContents(), app_info,
       base::Bind(&ArcNavigationThrottle::OnIntentPickerClosed,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&handlers)));
 }
 
 void ArcNavigationThrottle::OnIntentPickerClosed(
-    mojo::Array<mojom::IntentHandlerInfoPtr> handlers,
+    std::vector<mojom::IntentHandlerInfoPtr> handlers,
     const std::string& selected_app_package,
     CloseReason close_reason) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   const GURL& url = navigation_handle()->GetURL();
   content::NavigationHandle* handle = navigation_handle();
   previous_user_action_ = close_reason;
 
   // Make sure that the instance at least supports HandleUrl.
   auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
       "HandleUrl", kMinVersionForHandleUrl);
@@ skipping 49 matching lines @@
     }
   }
 
   Platform platform =
       GetDestinationPlatform(selected_app_package, close_reason);
   RecordUma(close_reason, platform);
 }
 
 // static
 size_t ArcNavigationThrottle::GetAppIndex(
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers,
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers,
     const std::string& selected_app_package) {
   for (size_t i = 0; i < handlers.size(); ++i) {
     if (handlers[i]->package_name == selected_app_package)
       return i;
   }
   return handlers.size();
 }
 
 // static
 ArcNavigationThrottle::Platform ArcNavigationThrottle::GetDestinationPlatform(
@@ skipping 20 matching lines @@
 
 // static
 bool ArcNavigationThrottle::ShouldOverrideUrlLoadingForTesting(
     const GURL& previous_url,
     const GURL& current_url) {
   return ShouldOverrideUrlLoading(previous_url, current_url);
 }
 
 // static
 bool ArcNavigationThrottle::IsAppAvailableForTesting(
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers) {
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers) {
   return IsAppAvailable(handlers);
 }
 
 // static
 size_t ArcNavigationThrottle::FindPreferredAppForTesting(
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers) {
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers) {
   return FindPreferredApp(handlers, GURL());
 }
 
 // static
 bool ArcNavigationThrottle::IsSwapElementsNeeded(
-    const mojo::Array<mojom::IntentHandlerInfoPtr>& handlers,
+    const std::vector<mojom::IntentHandlerInfoPtr>& handlers,
     std::pair<size_t, size_t>* out_indices) {
   size_t chrome_app_index = 0;
   for (size_t i = 0; i < handlers.size(); ++i) {
     if (ArcIntentHelperBridge::IsIntentHelperPackage(
             handlers[i]->package_name)) {
       chrome_app_index = i;
       break;
     }
   }
   if (chrome_app_index < ArcNavigationThrottle::kMaxAppResults)
     return false;
 
   *out_indices = std::make_pair(ArcNavigationThrottle::kMaxAppResults - 1,
                                 chrome_app_index);
   return true;
 }
 
 }  // namespace arc