Reusing Ok/Cancel buttons for intent picker

chrome/browser/chromeos/arc/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/arc_navigation_throttle.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 155 matching lines @@
     if (!handlers[i]->is_preferred)
       continue;
     if (ArcIntentHelperBridge::IsIntentHelperPackage(
             handlers[i]->package_name)) {
       // If Chrome browser was selected as the preferred app, we should't
       // create a throttle.
       DVLOG(1)
           << "Chrome browser is selected as the preferred app for this URL: "
           << navigation_handle()->GetURL().spec();
     }
-    OnIntentPickerClosed(std::move(handlers), i,
+    std::string package_name = handlers[i]->package_name;
+    OnIntentPickerClosed(std::move(handlers), package_name,
                          CloseReason::PREFERRED_ACTIVITY_FOUND);
     return;
   }
 
   // Swap Chrome app with any app in row |kMaxAppResults-1| iff his index is
   // bigger, thus ensuring the user can always see Chrome without scrolling.
   size_t chrome_app_index = 0;
   for (size_t i = 0; i < handlers.size(); ++i) {
     if (ArcIntentHelperBridge::IsIntentHelperPackage(
             handlers[i]->package_name)) {
@@ skipping 18 matching lines @@
   icon_loader->GetActivityIcons(
       activities,
       base::Bind(&ArcNavigationThrottle::OnAppIconsReceived,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&handlers)));
 }
 
 void ArcNavigationThrottle::OnAppIconsReceived(
     mojo::Array<mojom::IntentHandlerInfoPtr> handlers,
     std::unique_ptr<ActivityIconLoader::ActivityToIconsMap> icons) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  std::vector<NameAndIcon> app_info;
+  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(
-        handler->name, it != icons->end() ? it->second.icon20 : gfx::Image());
+        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,
-    size_t selected_app_index,
+    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);
-  if (!instance || selected_app_index >= handlers.size())
+  size_t selected_app_index = handlers.size();
+  if (!instance) {
     close_reason = CloseReason::ERROR;
+  } else if (close_reason == CloseReason::JUST_ONCE_PRESSED ||
+             close_reason == CloseReason::ALWAYS_PRESSED ||
+             close_reason == CloseReason::PREFERRED_ACTIVITY_FOUND) {
+    // Since we are selecting an app by its package name, we need to locate it
+    // on the |handlers| structure before sending the IPC to ARC.
+    for (size_t i = 0; i < handlers.size(); ++i) {
+      if (handlers[i]->package_name == selected_app_package) {
+        selected_app_index = i;
+        break;
+      }
+    }
+
+    if (selected_app_index == handlers.size())
+      close_reason = CloseReason::ERROR;
+  }
 
   switch (close_reason) {
     case CloseReason::ERROR:
     case CloseReason::DIALOG_DEACTIVATED: {
       // If the user fails to select an option from the list, or the UI returned
       // an error or if |selected_app_index| is not a valid index, then resume
       // the navigation in Chrome.
       DVLOG(1) << "User didn't select a valid option, resuming navigation.";
       handle->Resume();
       break;
     }
     case CloseReason::ALWAYS_PRESSED: {
       // Call AddPreferredPackage if it is supported. Reusing the same
       // |instance| is okay.
       if (ArcIntentHelperBridge::GetIntentHelperInstance(
               "AddPreferredPackage", kMinVersionForAddPreferredPackage)) {
         instance->AddPreferredPackage(
             handlers[selected_app_index]->package_name);
       }
       // fall through.
     }
     case CloseReason::JUST_ONCE_PRESSED:
     case CloseReason::PREFERRED_ACTIVITY_FOUND: {
       if (ArcIntentHelperBridge::IsIntentHelperPackage(
               handlers[selected_app_index]->package_name)) {
         handle->Resume();
       } else {
-        instance->HandleUrl(url.spec(),
-                            handlers[selected_app_index]->package_name);
+        instance->HandleUrl(url.spec(), selected_app_package);
         handle->CancelDeferredNavigation(
             content::NavigationThrottle::CANCEL_AND_IGNORE);
         if (handle->GetWebContents()->GetController().IsInitialNavigation())
           handle->GetWebContents()->Close();
       }
       break;
     }
     case CloseReason::INVALID: {
       NOTREACHED();
       return;
     }
   }
 
   UMA_HISTOGRAM_ENUMERATION("Arc.IntentHandlerAction",
                             static_cast<int>(close_reason),
                             static_cast<int>(CloseReason::SIZE));
 }
 
 // static
 bool ArcNavigationThrottle::ShouldOverrideUrlLoadingForTesting(
     const GURL& previous_url,
     const GURL& current_url) {
   return ShouldOverrideUrlLoading(previous_url, current_url);
 }
 
 }  // namespace arc