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

components/arc/intent_helper/arc_intent_helper_bridge.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 "components/arc/intent_helper/arc_intent_helper_bridge.h"
 
 #include <utility>
 #include <vector>
 
 #include "ash/common/new_window_delegate.h"
@@ skipping 30 matching lines @@
 }
 
 ArcIntentHelperBridge::~ArcIntentHelperBridge() {
   DCHECK(thread_checker_.CalledOnValidThread());
   arc_bridge_service()->intent_helper()->RemoveObserver(this);
 }
 
 void ArcIntentHelperBridge::OnInstanceReady() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ash::Shell::GetInstance()->set_link_handler_model_factory(this);
-  arc_bridge_service()->intent_helper()->instance()->Init(
-      binding_.CreateInterfacePtrAndBind());
+  auto* instance =
+      arc_bridge_service()->intent_helper()->GetInstanceForMethod("Init");
+  if (!instance)
+    return;
+  instance->Init(binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcIntentHelperBridge::OnInstanceClosed() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ash::Shell::GetInstance()->set_link_handler_model_factory(nullptr);
 }
 
 void ArcIntentHelperBridge::OnIconInvalidated(
     const mojo::String& package_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 51 matching lines @@
     if (IsIntentHelperPackage(handler->package_name.get()))
       continue;
     handlers_filtered.push_back(std::move(handler));
   }
   return handlers_filtered;
 }
 
 // static
 mojom::IntentHelperInstance*
 ArcIntentHelperBridge::GetIntentHelperInstanceWithErrorCode(
-    int min_instance_version,
+    const std::string& method_name_for_logging,
+    uint32_t min_instance_version,
     GetResult* out_error_code) {
   ArcBridgeService* bridge_service = ArcBridgeService::Get();
   if (!bridge_service) {
     if (!ArcBridgeService::GetEnabled(base::CommandLine::ForCurrentProcess())) {
       VLOG(2) << "ARC bridge is not supported.";
       if (out_error_code)
         *out_error_code = GetResult::FAILED_ARC_NOT_SUPPORTED;
     } else {
       VLOG(2) << "ARC bridge is not ready.";
       if (out_error_code)
         *out_error_code = GetResult::FAILED_ARC_NOT_READY;
     }
     return nullptr;
   }
-  mojom::IntentHelperInstance* intent_helper_instance =
-      bridge_service->intent_helper()->instance();
-  if (!intent_helper_instance) {
+
+  if (!bridge_service->intent_helper()->HasInstance()) {
     VLOG(2) << "ARC intent helper instance is not ready.";
     if (out_error_code)
       *out_error_code = GetResult::FAILED_ARC_NOT_READY;
     return nullptr;
   }
-  const int version = bridge_service->intent_helper()->version();
-  if (version < min_instance_version) {
-    VLOG(1) << "ARC intent helper instance is too old. required: "
-            << min_instance_version << ", actual: " << version;
+
+  auto* instance = bridge_service->intent_helper()->GetInstanceForMethod(
+      method_name_for_logging, min_instance_version);
+  if (!instance) {
     if (out_error_code)
       *out_error_code = GetResult::FAILED_ARC_NOT_SUPPORTED;
     return nullptr;
   }
-  return intent_helper_instance;
+  return instance;
 }
 
 // static
 mojom::IntentHelperInstance* ArcIntentHelperBridge::GetIntentHelperInstance(
-    int min_instance_version) {
-  return GetIntentHelperInstanceWithErrorCode(min_instance_version, nullptr);
+    const std::string& method_name_for_logging,
+    uint32_t min_instance_version) {
+  return GetIntentHelperInstanceWithErrorCode(method_name_for_logging,
+                                              min_instance_version, nullptr);
 }
 
 void ArcIntentHelperBridge::OnIntentFiltersUpdated(
     mojo::Array<mojom::IntentFilterPtr> filters) {
   DCHECK(thread_checker_.CalledOnValidThread());
   activity_resolver_->UpdateIntentFilters(std::move(filters));
 }
 
 }  // namespace arc