Always use arc::InstanceHolder<T>::GetInstanceForMethod

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"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/chromeos/arc/page_transition_util.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 "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_handle.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"
 #include "url/gurl.h"
 
 namespace arc {
 
 namespace {
 
-constexpr int kMinInstanceVersion = 7;
+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,
@@ skipping 63 matching lines @@
   const GURL& url = navigation_handle()->GetURL();
 
   if (ShouldIgnoreNavigation(navigation_handle()->GetPageTransition()))
     return content::NavigationThrottle::PROCEED;
 
   const GURL previous_url = navigation_handle()->GetReferrer().url;
   const GURL current_url = navigation_handle()->GetURL();
   if (!ShouldOverrideUrlLoading(previous_url, current_url))
     return content::NavigationThrottle::PROCEED;
 
-  arc::ArcServiceManager* arc_service_manager = arc::ArcServiceManager::Get();
+  ArcServiceManager* arc_service_manager = ArcServiceManager::Get();
   DCHECK(arc_service_manager);
-  scoped_refptr<arc::LocalActivityResolver> local_resolver =
+  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;
   }
 
-  mojom::IntentHelperInstance* bridge_instance =
-      arc::ArcIntentHelperBridge::GetIntentHelperInstance(kMinInstanceVersion);
-  if (!bridge_instance)
+  auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
+      "RequestUrlHandlerList", kMinVersionForRequestUrlHandlerList);
+  if (!instance)
     return content::NavigationThrottle::PROCEED;
-  bridge_instance->RequestUrlHandlerList(
+  instance->RequestUrlHandlerList(
       url.spec(), base::Bind(&ArcNavigationThrottle::OnAppCandidatesReceived,
                              weak_ptr_factory_.GetWeakPtr()));
   return content::NavigationThrottle::DEFER;
 }
 
 // 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) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 81 matching lines @@
 void ArcNavigationThrottle::OnIntentPickerClosed(
     mojo::Array<mojom::IntentHandlerInfoPtr> handlers,
     size_t selected_app_index,
     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;
 
-  mojom::IntentHelperInstance* bridge =
-      arc::ArcIntentHelperBridge::GetIntentHelperInstance(kMinInstanceVersion);
-  if (!bridge || selected_app_index >= handlers.size()) {
+  // Make sure that the instance at least supports HandleUrl.
+  auto* instance = ArcIntentHelperBridge::GetIntentHelperInstance(
+      "HandleUrl", kMinVersionForHandleUrl);
+  if (!instance || 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: {
-      bridge->AddPreferredPackage(handlers[selected_app_index]->package_name);
+      // 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 {
-        bridge->HandleUrl(url.spec(),
-                          handlers[selected_app_index]->package_name);
+        instance->HandleUrl(url.spec(),
+                            handlers[selected_app_index]->package_name);
         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