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

chrome/browser/chromeos/file_manager/arc_file_tasks.cc

 // Copyright (c) 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/file_manager/arc_file_tasks.h"
 
 #include <map>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
@@ skipping 24 matching lines @@
     FILE_PATH_LITERAL("/sdcard/Download");
 constexpr base::FilePath::CharType kRemovableMediaPath[] =
     FILE_PATH_LITERAL("/media/removable");
 constexpr char kArcRemovableMediaProviderUrl[] =
     "content://org.chromium.arc.removablemediaprovider/";
 constexpr char kAppIdSeparator = '/';
 constexpr char kPngDataUrlPrefix[] = "data:image/png;base64,";
 
 // Returns the Mojo interface for ARC Intent Helper, with version |minVersion|
 // or above. If the ARC bridge is not established, returns null.
-arc::mojom::IntentHelperInstance* GetArcIntentHelper(Profile* profile,
-                                                     uint32_t min_version) {
+arc::mojom::IntentHelperInstance* GetArcIntentHelper(
+    Profile* profile,
+    const std::string& method_name_for_logging,
+    uint32_t min_version) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // File manager in secondary profile cannot access ARC.
   if (!chromeos::ProfileHelper::IsPrimaryProfile(profile))
     return nullptr;
-  return arc::ArcIntentHelperBridge::GetIntentHelperInstance(min_version);
+  return arc::ArcIntentHelperBridge::GetIntentHelperInstance(
+      method_name_for_logging, min_version);
 }
 
 // Returns the icon loader that wraps the Mojo interface for ARC Intent Helper.
 scoped_refptr<arc::ActivityIconLoader> GetArcActivityIconLoader() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   arc::ArcServiceManager* arc_service_manager = arc::ArcServiceManager::Get();
   if (!arc_service_manager)
     return nullptr;
   return arc_service_manager->icon_loader();
@@ skipping 195 matching lines @@
 
 }  // namespace
 
 void FindArcTasks(Profile* profile,
                   const std::vector<extensions::EntryInfo>& entries,
                   std::unique_ptr<std::vector<FullTaskDescriptor>> result_list,
                   const FindTasksCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   arc::mojom::IntentHelperInstance* arc_intent_helper =
-      GetArcIntentHelper(profile, kArcIntentHelperVersionWithUrlListSupport);
+      GetArcIntentHelper(profile, "RequestUrlListHandlerList",
+                         kArcIntentHelperVersionWithUrlListSupport);
   if (!arc_intent_helper) {
     callback.Run(std::move(result_list));
     return;
   }
 
   mojo::Array<arc::mojom::UrlWithMimeTypePtr> urls;
   for (const extensions::EntryInfo& entry : entries) {
     if (entry.is_directory) {  // ARC apps don't support directories.
       callback.Run(std::move(result_list));
       return;
@@ skipping 17 matching lines @@
 }
 
 bool ExecuteArcTask(Profile* profile,
                     const TaskDescriptor& task,
                     const std::vector<storage::FileSystemURL>& file_urls,
                     const std::vector<std::string>& mime_types) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(file_urls.size(), mime_types.size());
 
   arc::mojom::IntentHelperInstance* const arc_intent_helper =
-      GetArcIntentHelper(profile, kArcIntentHelperVersionWithUrlListSupport);
+      GetArcIntentHelper(profile, "HandleUrlListDeprecated",
+                         kArcIntentHelperVersionWithUrlListSupport);
   if (!arc_intent_helper)
     return false;
 
   mojo::Array<arc::mojom::UrlWithMimeTypePtr> urls;
   for (size_t i = 0; i < file_urls.size(); ++i) {
     GURL url;
     if (!ConvertToArcUrl(file_urls[i].path(), &url)) {
       LOG(ERROR) << "File on unsuppored path";
       return false;
     }
 
     arc::mojom::UrlWithMimeTypePtr url_with_type =
         arc::mojom::UrlWithMimeType::New();
     url_with_type->url = url.spec();
     url_with_type->mime_type = mime_types[i];
     urls.push_back(std::move(url_with_type));
   }
 
-  if (GetArcIntentHelper(profile,
+  if (GetArcIntentHelper(profile, "HandleUrlList",
                          kArcIntentHelperVersionWithFullActivityName)) {
     arc_intent_helper->HandleUrlList(std::move(urls),
                                      AppIdToActivityName(task.app_id),
                                      StringToArcAction(task.action_id));
   } else {
     arc_intent_helper->HandleUrlListDeprecated(
         std::move(urls), AppIdToActivityName(task.app_id)->package_name,
         StringToArcAction(task.action_id));
   }
   return true;
 }
 
 }  // namespace file_tasks
 }  // namespace file_manager