Use ARC_GET_INSTANCE_FOR_METHOD for getting intent_helper instance

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 "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 16 matching lines @@
 #include "ui/base/window_open_disposition.h"
 #include "ui/gfx/image/image.h"
 #include "url/gurl.h"
 
 using content::WebContents;
 
 namespace arc {
 
 namespace {
 
-constexpr uint32_t kMinVersionForHandleUrl = 2;
-constexpr uint32_t kMinVersionForRequestUrlHandlerList = 2;
-constexpr uint32_t kMinVersionForAddPreferredPackage = 7;
-
 // TODO(yusukes|djacobo): Find a better way to detect a request loop and remove
 // the global variables.
 base::LazyInstance<GURL> g_last_url = LAZY_INSTANCE_INITIALIZER;
 ui::PageTransition g_last_page_transition;
 
 // Shows the Chrome OS' original external protocol dialog as a fallback.
 void ShowFallbackExternalProtocolDialog(int render_process_host_id,
                                         int routing_id,
                                         const GURL& url) {
   WebContents* web_contents =
@@ skipping 32 matching lines @@
       // TODO(yusukes): Send a non-empty referrer.
       url, content::Referrer(), WindowOpenDisposition::CURRENT_TAB,
       page_transition_type, kIsRendererInitiated);
   web_contents->OpenURL(params);
 }
 
 // Sends |url| to ARC.
 void HandleUrlInArc(int render_process_host_id,
                     int routing_id,
                     const std::pair<GURL, std::string>& url_and_package) {
-  auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
-      "HandleUrl", kMinVersionForHandleUrl);
+  auto* arc_service_manager = ArcServiceManager::Get();
+  if (!arc_service_manager)
+    return;
+  auto* instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_service_manager->arc_bridge_service()->intent_helper(), HandleUrl);
   if (!instance)
     return;
 
   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,
@@ skipping 148 matching lines @@
                           const GURL& url,
                           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(
-      "HandleUrl", kMinVersionForHandleUrl);
+  auto* arc_service_manager = ArcServiceManager::Get();
+  mojom::IntentHelperInstance* instance = nullptr;
+  if (arc_service_manager) {
+    instance = ARC_GET_INSTANCE_FOR_METHOD(
+        arc_service_manager->arc_bridge_service()->intent_helper(), HandleUrl);
+  }
+
   if (!instance) {
     close_reason = ArcNavigationThrottle::CloseReason::ERROR;
   } else if (close_reason ==
                  ArcNavigationThrottle::CloseReason::JUST_ONCE_PRESSED ||
              close_reason ==
                  ArcNavigationThrottle::CloseReason::ALWAYS_PRESSED) {
     if (selected_app_index == handlers.size()) {
       close_reason = ArcNavigationThrottle::CloseReason::ERROR;
     } else {
       // The user has made a selection. Clear g_last_* variables.
       g_last_url.Get() = GURL();
       g_last_page_transition = ui::PageTransition();
     }
   }
 
   switch (close_reason) {
     case ArcNavigationThrottle::CloseReason::ALWAYS_PRESSED: {
-      if (ArcIntentHelperBridge::GetIntentHelperInstance(
-              "AddPreferredPackage", kMinVersionForAddPreferredPackage)) {
+      DCHECK(arc_service_manager);
+      if (ARC_GET_INSTANCE_FOR_METHOD(
+              arc_service_manager->arc_bridge_service()->intent_helper(),
+              AddPreferredPackage)) {
         instance->AddPreferredPackage(
             handlers[selected_app_index]->package_name);
       }
       // fall through.
     }
     case ArcNavigationThrottle::CloseReason::JUST_ONCE_PRESSED: {
       // Launch the selected app.
       HandleUrl(render_process_host_id, routing_id, url, false, handlers,
                 selected_app_index, nullptr);
       break;
@@ skipping 26 matching lines @@
 
 // Called when ARC returned activity icons for the |handlers|.
 void OnAppIconsReceived(
     int render_process_host_id,
     int routing_id,
     const GURL& url,
     std::vector<mojom::IntentHandlerInfoPtr> handlers,
     std::unique_ptr<ActivityIconLoader::ActivityToIconsMap> icons) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  using AppInfo = arc::ArcNavigationThrottle::AppInfo;
+  using AppInfo = 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,
                       bool always_ask_user,
                       std::vector<mojom::IntentHandlerInfoPtr> handlers) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
-      "HandleUrl", kMinVersionForHandleUrl);
+  auto* arc_service_manager = ArcServiceManager::Get();
+  if (!arc_service_manager) {
+    // ARC is not running anymore. Show the Chrome OS dialog.
+    ShowFallbackExternalProtocolDialog(render_process_host_id, routing_id, url);
+    return;
+  }
+
+  auto* instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_service_manager->arc_bridge_service()->intent_helper(), HandleUrl);
   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;
   }
 
   // Check if the |url| should be handled right away without showing the UI.
   GetActionResult result;
@@ skipping 79 matching lines @@
       MaskOutPageTransition(page_transition, ui::PAGE_TRANSITION_FROM_API);
 
   if (ShouldIgnoreNavigation(masked_page_transition,
                              true /* allow_form_submit */,
                              true /* allow_client_redirect */)) {
     LOG(WARNING) << "RunArcExternalProtocolDialog: ignoring " << url
                  << " with PageTransition=" << masked_page_transition;
     return false;
   }
 
-  auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
-      "RequestUrlHandlerList", kMinVersionForRequestUrlHandlerList);
+  auto* arc_service_manager = ArcServiceManager::Get();
+  if (!arc_service_manager)
+    return false;  // ARC is either not supported or not yet ready.
+
+  auto* instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_service_manager->arc_bridge_service()->intent_helper(),
+      RequestUrlHandlerList);
   if (!instance)
-    return false;  // ARC is either not supported or not yet ready.
+    return false;  // the same.
 
   WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_host_id, routing_id);
   if (!web_contents || !web_contents->GetBrowserContext() ||
       web_contents->GetBrowserContext()->IsOffTheRecord()) {
     return false;
   }
 
   // Show ARC version of the dialog, which is IntentPickerBubbleView. To show
   // the bubble view, we need to ask ARC for a handler list first.
@@ skipping 21 matching lines @@
 bool IsSafeToRedirectToArcWithoutUserConfirmationForTesting(
     const GURL& url,
     ui::PageTransition page_transition,
     const GURL& last_url,
     ui::PageTransition last_page_transition) {
   return IsSafeToRedirectToArcWithoutUserConfirmation(
       url, page_transition, last_url, last_page_transition);
 }
 
 }  // namespace arc