Use ARC_GET_INSTANCE_FOR_METHOD for getting intent_helper instance

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"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
 #include "components/arc/intent_helper/arc_intent_helper_bridge.h"
 #include "components/arc/intent_helper/local_activity_resolver.h"
 #include "components/arc/intent_helper/page_transition_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "ui/base/page_transition_types.h"
 
 namespace arc {
 
 namespace {
 
-constexpr uint32_t kMinVersionForHandleUrl = 2;
-constexpr uint32_t kMinVersionForRequestUrlHandlerList = 2;
-constexpr uint32_t kMinVersionForAddPreferredPackage = 7;
-
 scoped_refptr<ActivityIconLoader> GetIconLoader() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   ArcServiceManager* arc_service_manager = ArcServiceManager::Get();
   return arc_service_manager ? arc_service_manager->icon_loader() : nullptr;
 }
 
 // Compares the host name of the referrer and target URL to decide whether
 // the navigation needs to be overriden.
 bool ShouldOverrideUrlLoading(const GURL& previous_url,
                               const GURL& current_url) {
@@ skipping 131 matching lines @@
     return content::NavigationThrottle::PROCEED;
 
   if (ShouldIgnoreNavigation(navigation_handle()->GetPageTransition(),
                              kAllowFormSubmit, kAllowClientRedirect))
     return content::NavigationThrottle::PROCEED;
 
   if (!ShouldOverrideUrlLoading(starting_gurl_, url))
     return content::NavigationThrottle::PROCEED;
 
   ArcServiceManager* arc_service_manager = ArcServiceManager::Get();
-  DCHECK(arc_service_manager);
+  if (!arc_service_manager)
+    return content::NavigationThrottle::PROCEED;
+
   scoped_refptr<LocalActivityResolver> local_resolver =
       arc_service_manager->activity_resolver();
   if (local_resolver->ShouldChromeHandleUrl(url)) {
     // Allow navigation to proceed if there isn't an android app that handles
     // the given URL.
     return content::NavigationThrottle::PROCEED;
   }
 
-  auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
-      "RequestUrlHandlerList", kMinVersionForRequestUrlHandlerList);
+  auto* instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_service_manager->arc_bridge_service()->intent_helper(),
+      RequestUrlHandlerList);
   if (!instance)
     return content::NavigationThrottle::PROCEED;
   instance->RequestUrlHandlerList(
       url.spec(), base::Bind(&ArcNavigationThrottle::OnAppCandidatesReceived,
                              weak_ptr_factory_.GetWeakPtr()));
   return content::NavigationThrottle::DEFER;
 }
 
 GURL ArcNavigationThrottle::GetStartingGURL() const {
   // This helps us determine a reference GURL for the current NavigationHandle.
@@ skipping 83 matching lines @@
 void ArcNavigationThrottle::OnIntentPickerClosed(
     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);
+  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);
+  }
+
   // 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.
   const size_t selected_app_index = GetAppIndex(handlers, selected_app_package);
   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) {
     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)) {
+      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 CloseReason::JUST_ONCE_PRESSED:
     case CloseReason::PREFERRED_ACTIVITY_FOUND: {
       if (ArcIntentHelperBridge::IsIntentHelperPackage(
               handlers[selected_app_index]->package_name)) {
         handle->Resume();
@@ skipping 84 matching lines @@
   }
   if (chrome_app_index < ArcNavigationThrottle::kMaxAppResults)
     return false;
 
   *out_indices = std::make_pair(ArcNavigationThrottle::kMaxAppResults - 1,
                                 chrome_app_index);
   return true;
 }
 
 }  // namespace arc