Get rid of RefCounted for ActivityIconLoader.

components/arc/intent_helper/link_handler_model_impl.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/link_handler_model_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.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/google/core/browser/google_util.h"
-#include "url/gurl.h"
 #include "url/url_util.h"
 
 namespace arc {
 
 namespace {
 
 constexpr int kMaxValueLen = 2048;
 
 bool GetQueryValue(const GURL& url,
                    const std::string& key_to_find,
@@ skipping 15 matching lines @@
                                     &output);
       *out = base::string16(output.data(), output.length());
       return true;
     }
   }
   return false;
 }
 
 }  // namespace
 
-LinkHandlerModelImpl::LinkHandlerModelImpl(
-    scoped_refptr<ActivityIconLoader> icon_loader)
-    : icon_loader_(icon_loader), weak_ptr_factory_(this) {}
+LinkHandlerModelImpl::LinkHandlerModelImpl() : weak_ptr_factory_(this) {}
 
-LinkHandlerModelImpl::~LinkHandlerModelImpl() {}
+LinkHandlerModelImpl::~LinkHandlerModelImpl() = default;
 
 bool LinkHandlerModelImpl::Init(const GURL& url) {
   auto* arc_service_manager = ArcServiceManager::Get();
   if (!arc_service_manager)
     return false;
   auto* instance = ARC_GET_INSTANCE_FOR_METHOD(
       arc_service_manager->arc_bridge_service()->intent_helper(),
       RequestUrlHandlerList);
   if (!instance)
     return false;
@@ skipping 26 matching lines @@
     return;
   const GURL rewritten(RewriteUrlFromQueryIfAvailable(url));
   instance->HandleUrl(rewritten.spec(), handlers_[handler_id]->package_name);
 }
 
 void LinkHandlerModelImpl::OnUrlHandlerList(
     std::vector<mojom::IntentHandlerInfoPtr> handlers) {
   handlers_ = ArcIntentHelperBridge::FilterOutIntentHelper(std::move(handlers));
 
   bool icon_info_notified = false;
-  if (icon_loader_) {
-    std::vector<ActivityIconLoader::ActivityName> activities;
+  auto* intent_helper_bridge =
+      ArcServiceManager::GetGlobalService<ArcIntentHelperBridge>();
+  if (intent_helper_bridge) {
+    std::vector<ArcIntentHelperBridge::ActivityName> activities;
     for (size_t i = 0; i < handlers_.size(); ++i) {
       activities.emplace_back(handlers_[i]->package_name,
                               handlers_[i]->activity_name);
     }
-    const ActivityIconLoader::GetResult result = icon_loader_->GetActivityIcons(
-        activities, base::Bind(&LinkHandlerModelImpl::NotifyObserver,
-                               weak_ptr_factory_.GetWeakPtr()));
-    icon_info_notified = ActivityIconLoader::HasIconsReadyCallbackRun(result);
+    const ArcIntentHelperBridge::GetResult result =
+        intent_helper_bridge->GetActivityIcons(
+            activities, base::Bind(&LinkHandlerModelImpl::NotifyObserver,
+                                   weak_ptr_factory_.GetWeakPtr()));
+    icon_info_notified =
+        internal::ActivityIconLoader::HasIconsReadyCallbackRun(result);
   }
 
   if (!icon_info_notified) {
     // Call NotifyObserver() without icon information, unless
     // GetActivityIcons has already called it. Otherwise if we delay the
     // notification waiting for all icons, context menu may flicker.
     NotifyObserver(nullptr);
   }
 }
 
 void LinkHandlerModelImpl::NotifyObserver(
-    std::unique_ptr<ActivityIconLoader::ActivityToIconsMap> icons) {
+    std::unique_ptr<ArcIntentHelperBridge::ActivityToIconsMap> icons) {
   if (icons) {
     icons_.insert(icons->begin(), icons->end());
     icons.reset();
   }
 
   std::vector<ash::LinkHandlerInfo> handlers;
   for (size_t i = 0; i < handlers_.size(); ++i) {
     gfx::Image icon;
-    const ActivityIconLoader::ActivityName activity(
+    const ArcIntentHelperBridge::ActivityName activity(
         handlers_[i]->package_name, handlers_[i]->activity_name);
     const auto it = icons_.find(activity);
     if (it != icons_.end())
       icon = it->second.icon16;
     // Use the handler's index as an ID.
     ash::LinkHandlerInfo handler = {handlers_[i]->name, icon, i};
     handlers.push_back(handler);
   }
   for (auto& observer : observer_list_)
     observer.ModelChanged(handlers);
@@ skipping 21 matching lines @@
   if (!GetQueryValue(url, kKeyToFind, &value))
     return url;
 
   const GURL new_url(value);
   if (!new_url.is_valid())
     return url;
   return new_url;
 }
 
 }  // namespace arc