arc: Use ARC_GET_INSTANCE_FOR_METHOD for getting app instance

chrome/browser/ui/app_list/arc/arc_app_utils.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/ui/app_list/arc/arc_app_utils.h"
 
 #include <memory>
 #include <string>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_deferred_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_shelf_id.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
 #include "components/arc/common/intent_helper.mojom.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_constants.h"
 
+// Helper macro which returns the AppInstance.
+#define GET_APP_INSTANCE(method_name)                                    \
+  (arc::ArcServiceManager::Get()                                         \
+       ? ARC_GET_INSTANCE_FOR_METHOD(                                    \
+             arc::ArcServiceManager::Get()->arc_bridge_service()->app(), \
+             method_name)                                                \
+       : nullptr)
+
+// Helper function which returns the IntentHelperInstance.
+#define GET_INTENT_HELPER_INSTANCE(method_name)                    \
+  (arc::ArcServiceManager::Get()                                   \
+       ? ARC_GET_INSTANCE_FOR_METHOD(arc::ArcServiceManager::Get() \
+                                         ->arc_bridge_service()    \
+                                         ->intent_helper(),        \
+                                     method_name)                  \
+       : nullptr)
+
 namespace arc {
 
 namespace {
 
 // Default sizes to use.
 constexpr int kNexus7Width = 960;
 constexpr int kNexus7Height = 600;
 constexpr int kNexus5Width = 410;
 constexpr int kNexus5Height = 690;
 
-// Minimum required versions.
-constexpr uint32_t kMinVersion = 0;
-constexpr uint32_t kCanHandleResolutionMinVersion = 1;
-constexpr uint32_t kSendBroadcastMinVersion = 1;
-constexpr uint32_t kUninstallPackageMinVersion = 2;
-constexpr uint32_t kTaskSupportMinVersion = 3;
-constexpr uint32_t kShowPackageInfoMinVersion = 5;
-constexpr uint32_t kRemoveIconMinVersion = 9;
-constexpr uint32_t kShowPackageInfoOnPageMinVersion = 10;
-
-// Service name strings.
-constexpr char kCanHandleResolutionStr[] = "get resolution capability";
-constexpr char kCloseTaskStr[] = "close task";
-constexpr char kLaunchAppStr[] = "launch app";
-constexpr char kRemoveIconStr[] = "remove icon";
-constexpr char kSetActiveTaskStr[] = "set active task";
-constexpr char kShowPackageInfoStr[] = "show package info";
-constexpr char kUninstallPackageStr[] = "uninstall package";
-
 // Intent helper strings.
 constexpr char kIntentHelperClassName[] =
     "org.chromium.arc.intent_helper.SettingsReceiver";
 constexpr char kIntentHelperPackageName[] = "org.chromium.arc.intent_helper";
-constexpr char kSendBroadcastStr[] = "SendBroadcast";
 constexpr char kSetInTouchModeIntent[] =
     "org.chromium.arc.intent_helper.SET_IN_TOUCH_MODE";
 constexpr char kShowTalkbackSettingsIntent[] =
     "org.chromium.arc.intent_helper.SHOW_TALKBACK_SETTINGS";
 
-// Helper function which returns the AppInstance. Create related logs when error
-// happens.
-arc::mojom::AppInstance* GetAppInstance(uint32_t required_version,
-                                        const std::string& service_name) {
-  auto* arc_service_manager = arc::ArcServiceManager::Get();
-  if (!arc_service_manager) {
-    VLOG(2) << "Request to " << service_name
-            << " when bridge service is not ready.";
-    return nullptr;
-  }
-
-  return arc_service_manager->arc_bridge_service()
-      ->app()
-      ->GetInstanceForVersion(required_version, service_name.c_str());
-}
-
-// Helper function which returns the IntentHelperInstance. Create related logs
-// when error happens.
-arc::mojom::IntentHelperInstance* GetIntentHelperInstance(
-    uint32_t required_version,
-    const std::string& service_name) {
-  auto* arc_service_manager = arc::ArcServiceManager::Get();
-  if (!arc_service_manager) {
-    VLOG(2) << "Request to " << service_name
-            << " when bridge service is not ready.";
-    return nullptr;
-  }
-
-  return arc_service_manager->arc_bridge_service()
-      ->intent_helper()
-      ->GetInstanceForVersion(required_version, service_name.c_str());
-}
-
 void PrioritizeArcInstanceCallback(bool success) {
   VLOG(2) << "Finished prioritizing the instance: result=" << success;
   if (!success)
     LOG(ERROR) << "Failed to prioritize ARC";
 }
 
 // Find a proper size and position for a given rectangle on the screen.
 // TODO(skuhne): This needs more consideration, but it is lacking
 // WindowPositioner functionality since we do not have an Aura::Window yet.
 gfx::Rect GetTargetRect(const gfx::Size& size) {
@@ skipping 124 matching lines @@
   if (!app_info->ready) {
     VLOG(2) << "Cannot launch not-ready app: " << app_id << ".";
     return false;
   }
 
   if (!app_info->launchable) {
     VLOG(2) << "Cannot launch non-launchable app: " << app_id << ".";
     return false;
   }
 
-  arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kMinVersion, kLaunchAppStr);
+  arc::mojom::AppInstance* app_instance = GET_APP_INSTANCE(LaunchApp);
   if (!app_instance)
     return false;
 
   arc::mojom::IntentHelperInstance* intent_helper_instance =
-      GetIntentHelperInstance(kSendBroadcastMinVersion, kSendBroadcastStr);
+      GET_INTENT_HELPER_INSTANCE(SendBroadcast);
   if (intent_helper_instance) {
     base::DictionaryValue extras;
     extras.SetBoolean("inTouchMode", IsMouseOrTouchEventFromFlags(event_flags));
     std::string extras_string;
     base::JSONWriter::Write(extras, &extras_string);
     intent_helper_instance->SendBroadcast(
         kSetInTouchModeIntent, kIntentHelperPackageName, kIntentHelperClassName,
         extras_string);
   }
 
   if (app_info->shortcut) {
+    // Before calling LaunchIntent, check if the interface is supported. Reusing
+    // the same |app_instance| for LaunchIntent is allowed.
+    if (!GET_APP_INSTANCE(LaunchIntent))
+      return false;
     app_instance->LaunchIntent(app_info->intent_uri, target_rect);
   } else {
     app_instance->LaunchApp(app_info->package_name, app_info->activity,
                             target_rect);
   }
   prefs->SetLastLaunchTime(app_id, base::Time::Now());
 
   return true;
 }
 
@@ skipping 61 matching lines @@
     prefs->SetLastLaunchTime(app_id, base::Time::Now());
     return true;
   }
 
   return (new LaunchAppWithoutSize(context, app_id, landscape_layout,
                                    event_flags))
       ->LaunchAndRelease();
 }
 
 void SetTaskActive(int task_id) {
-  arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kTaskSupportMinVersion, kSetActiveTaskStr);
+  arc::mojom::AppInstance* app_instance = GET_APP_INSTANCE(SetTaskActive);
   if (!app_instance)
     return;
   app_instance->SetTaskActive(task_id);
 }
 
 void CloseTask(int task_id) {
-  arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kTaskSupportMinVersion, kCloseTaskStr);
+  arc::mojom::AppInstance* app_instance = GET_APP_INSTANCE(CloseTask);
   if (!app_instance)
     return;
   app_instance->CloseTask(task_id);
 }
 
 void ShowTalkBackSettings() {
   arc::mojom::IntentHelperInstance* intent_helper_instance =
-      GetIntentHelperInstance(kSendBroadcastMinVersion, kSendBroadcastStr);
+      GET_INTENT_HELPER_INSTANCE(SendBroadcast);
   if (!intent_helper_instance)
     return;
 
   intent_helper_instance->SendBroadcast(kShowTalkbackSettingsIntent,
                                         kIntentHelperPackageName,
                                         kIntentHelperClassName, "{}");
 }
 
 bool CanHandleResolution(content::BrowserContext* context,
                          const std::string& app_id,
                          const gfx::Rect& rect,
                          const CanHandleResolutionCallback& callback) {
   const ArcAppListPrefs* prefs = ArcAppListPrefs::Get(context);
   DCHECK(prefs);
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(app_id);
   if (!app_info) {
     VLOG(2) << "Cannot test resolution capability of unavailable app:" << app_id
             << ".";
     return false;
   }
 
-  arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kCanHandleResolutionMinVersion, kCanHandleResolutionStr);
+  arc::mojom::AppInstance* app_instance = GET_APP_INSTANCE(CanHandleResolution);
   if (!app_instance)
     return false;
 
   app_instance->CanHandleResolution(app_info->package_name, app_info->activity,
                                     rect, callback);
   return true;
 }
 
 void UninstallPackage(const std::string& package_name) {
   VLOG(2) << "Uninstalling " << package_name;
 
-  arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kUninstallPackageMinVersion, kUninstallPackageStr);
+  arc::mojom::AppInstance* app_instance = GET_APP_INSTANCE(UninstallPackage);
   if (!app_instance)
     return;
 
   app_instance->UninstallPackage(package_name);
 }
 
 void UninstallArcApp(const std::string& app_id, Profile* profile) {
   ArcAppListPrefs* arc_prefs = ArcAppListPrefs::Get(profile);
   DCHECK(arc_prefs);
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
       arc_prefs->GetApp(app_id);
   if (!app_info) {
     VLOG(2) << "Package being uninstalled does not exist: " << app_id << ".";
     return;
   }
   // For shortcut we just remove the shortcut instead of the package.
   if (app_info->shortcut)
     arc_prefs->RemoveApp(app_id);
   else
     UninstallPackage(app_info->package_name);
 }
 
 void RemoveCachedIcon(const std::string& icon_resource_id) {
   VLOG(2) << "Removing icon " << icon_resource_id;
 
-  arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kRemoveIconMinVersion, kRemoveIconStr);
+  arc::mojom::AppInstance* app_instance = GET_APP_INSTANCE(RemoveCachedIcon);
   if (!app_instance)
     return;
 
   app_instance->RemoveCachedIcon(icon_resource_id);
 }
 
 // Deprecated.
 bool ShowPackageInfo(const std::string& package_name) {
   VLOG(2) << "Showing package info for " << package_name;
 
   arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kShowPackageInfoMinVersion, kShowPackageInfoStr);
+      GET_APP_INSTANCE(ShowPackageInfoDeprecated);
   if (!app_instance)
     return false;
 
   app_instance->ShowPackageInfoDeprecated(
       package_name, GetTargetRect(gfx::Size(kNexus7Width, kNexus7Height)));
   return true;
 }
 
 bool ShowPackageInfoOnPage(const std::string& package_name,
                            mojom::ShowPackageInfoPage page) {
   VLOG(2) << "Showing package info for " << package_name;
 
   arc::mojom::AppInstance* app_instance =
-      GetAppInstance(kShowPackageInfoOnPageMinVersion, kShowPackageInfoStr);
+      GET_APP_INSTANCE(ShowPackageInfoOnPage);
   if (!app_instance)
     return false;
 
   app_instance->ShowPackageInfoOnPage(
       package_name, page,
       GetTargetRect(gfx::Size(kNexus7Width, kNexus7Height)));
   return true;
 }
 
 bool IsArcItem(content::BrowserContext* context, const std::string& id) {
   DCHECK(context);
 
   // Some unit tests use empty id.
   if (id.empty())
     return false;
 
   const ArcAppListPrefs* const arc_prefs = ArcAppListPrefs::Get(context);
   if (!arc_prefs)
     return false;
 
   return arc_prefs->IsRegistered(ArcAppShelfId::FromString(id).app_id());
 }
 
 }  // namespace arc