Get rid of RefCounted for ActivityIconLoader.

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"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/chromeos/arc/intent_helper/arc_navigation_throttle.h"
 #include "chrome/browser/chromeos/external_protocol_dialog.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
-#include "components/arc/intent_helper/activity_icon_loader.h"
 #include "components/arc/intent_helper/arc_intent_helper_bridge.h"
 #include "components/arc/intent_helper/page_transition_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/referrer.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/base/window_open_disposition.h"
 #include "ui/gfx/image/image.h"
@@ skipping 12 matching lines @@
 
 // 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 =
       tab_util::GetWebContentsByID(render_process_host_id, routing_id);
   new ExternalProtocolDialog(web_contents, url);
 }
 
-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;
-}
-
 void CloseTabIfNeeded(int render_process_host_id, int routing_id) {
   WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_host_id, routing_id);
   if (web_contents && web_contents->GetController().IsInitialNavigation())
     web_contents->Close();
 }
 
 // Shows |url| in the current tab.
 void OpenUrlInChrome(int render_process_host_id,
                      int routing_id,
@@ skipping 258 matching lines @@
                                                     close_reason);
   ArcNavigationThrottle::RecordUma(close_reason, platform);
 }
 
 // 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) {
+    std::unique_ptr<ArcIntentHelperBridge::ActivityToIconsMap> icons) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   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 ArcIntentHelperBridge::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,
@@ skipping 11 matching lines @@
 
   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) {
+  auto* intent_helper_bridge =
+      ArcServiceManager::GetGlobalService<ArcIntentHelperBridge>();
+  if (!instance || !intent_helper_bridge) {
     // 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;
   if (HandleUrl(render_process_host_id, routing_id, url, always_ask_user,
                 handlers, handlers.size(), &result)) {
     if (result == GetActionResult::HANDLE_URL_IN_ARC) {
       ArcNavigationThrottle::RecordUma(
           ArcNavigationThrottle::CloseReason::PREFERRED_ACTIVITY_FOUND,
           ArcNavigationThrottle::Platform::ARC);
     }
     return;  // the |url| has been handled.
   }
 
   // Otherwise, retrieve icons of the activities. First, swap |handler| elements
   // to ensure Chrome is visible in the UI by default. Since this function is
   // for handling external protocols, Chrome is rarely in the list, but if the
   // |url| is intent: with fallback or geo:, for example, it may be.
   std::pair<size_t, size_t> indices;
   if (ArcNavigationThrottle::IsSwapElementsNeeded(handlers, &indices))
     std::swap(handlers[indices.first], handlers[indices.second]);
 
   // Then request the icons.
-  std::vector<ActivityIconLoader::ActivityName> activities;
+  std::vector<ArcIntentHelperBridge::ActivityName> activities;
   for (const auto& handler : handlers) {
     activities.emplace_back(handler->package_name, handler->activity_name);
   }
-  icon_loader->GetActivityIcons(
+  intent_helper_bridge->GetActivityIcons(
       activities, base::Bind(OnAppIconsReceived, render_process_host_id,
                              routing_id, url, base::Passed(&handlers)));
 }
 
 // Returns true if the |url| is safe to be forwarded to ARC without showing the
 // disambig dialog when there is a preferred app on ARC for the |url|. Note that
 // this function almost always returns true (i.e. "safe") except for very rare
 // situations mentioned below.
 // TODO(yusukes|djacobo): Find a better way to detect a request loop and remove
 // these heuristics.
@@ skipping 95 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