Reland "Propagate information about how ARC apps are launched"

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/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/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/common/intent_helper.mojom.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
+#include "ui/events/event_utils.h"
 
 namespace arc {
 
 namespace {
 
 // Default sizes to use.
 constexpr int kNexus7Width = 960;
 constexpr int kNexus7Height = 600;
 constexpr int kNexus5Width = 410;
 constexpr int kNexus5Height = 690;
@@ skipping 10 matching lines @@
 
 // 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 kIntentHelperPackageName[] = "org.chromium.arc.intent_helper";
+constexpr char kIntentHelperClassName[] =
+    "org.chromium.arc.intent_helper.SettingsReceiver";
+
 // 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) {
   arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
   if (!bridge_service) {
     VLOG(2) << "Request to " << service_name
             << " when bridge service is not ready.";
     return nullptr;
   }
@@ skipping 40 matching lines @@
 }
 
 // A class which handles the asynchronous ARC runtime callback to figure out if
 // an app can handle a certain resolution or not.
 // After LaunchAndRelease() got called, the object will destroy itself once
 // done.
 class LaunchAppWithoutSize {
  public:
   LaunchAppWithoutSize(content::BrowserContext* context,
                        const std::string& app_id,
-                       bool landscape_mode)
-      : context_(context), app_id_(app_id), landscape_mode_(landscape_mode) {}
+                       bool landscape_mode,
+                       int event_flags)
+      : context_(context),
+        app_id_(app_id),
+        landscape_mode_(landscape_mode),
+        event_flags_(event_flags) {}
 
   // This will launch the request and after the return the creator does not
   // need to delete the object anymore.
   bool LaunchAndRelease() {
     landscape_ = landscape_mode_ ? gfx::Rect(0, 0, kNexus7Width, kNexus7Height)
                                  : gfx::Rect(0, 0, kNexus5Width, kNexus5Height);
     if (!ash::Shell::HasInstance()) {
       // Skip this if there is no Ash shell.
-      LaunchAppWithRect(context_, app_id_, landscape_);
+      LaunchAppWithRect(context_, app_id_, landscape_, event_flags_);
       delete this;
       return true;
     }
 
     // TODO(skuhne): Change CanHandleResolution into a call which returns
     // capability flags like [PHONE/TABLET]_[LANDSCAPE/PORTRAIT] and which
     // might also return the used DP->PIX conversion constant to do better
     // size calculations.
     bool result = CanHandleResolution(
         context_, app_id_, landscape_,
         base::Bind(&LaunchAppWithoutSize::Callback, base::Unretained(this)));
     if (!result)
       delete this;
 
     return result;
   }
 
  private:
   content::BrowserContext* context_;
   const std::string app_id_;
   const bool landscape_mode_;
   gfx::Rect landscape_;
+  const int event_flags_;
 
   // The callback handler which gets called from the CanHandleResolution
   // function.
   void Callback(bool can_handle) {
     gfx::Size target_size =
         can_handle ? landscape_.size() : gfx::Size(kNexus5Width, kNexus5Height);
-    LaunchAppWithRect(context_, app_id_, GetTargetRect(target_size));
+    LaunchAppWithRect(context_, app_id_, GetTargetRect(target_size),
+                      event_flags_);
     // Now that we are done, we can delete ourselves.
     delete this;
   }
 
   DISALLOW_COPY_AND_ASSIGN(LaunchAppWithoutSize);
 };
 
 }  // namespace
 
 const char kPlayStoreAppId[] = "gpkmicpkkebkmabiaedjognfppcchdfa";
 const char kPlayStorePackage[] = "com.android.vending";
 const char kPlayStoreActivity[] = "com.android.vending.AssetBrowserActivity";
 const char kSettingsAppId[] = "mconboelelhjpkbdhhiijkgcimoangdj";
 
 bool ShouldShowInLauncher(const std::string& app_id) {
   return (app_id != kSettingsAppId);
 }
 
 bool LaunchAppWithRect(content::BrowserContext* context,
                        const std::string& app_id,
-                       const gfx::Rect& target_rect) {
+                       const gfx::Rect& target_rect,
+                       int event_flags) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(context);
   CHECK(prefs);
 
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(app_id);
   if (!app_info) {
     VLOG(2) << "Cannot launch unavailable app: " << app_id << ".";
     return false;
   }
 
   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);
   if (!app_instance)
     return false;
 
+  arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
+  DCHECK(bridge_service);
+  auto* intent_helper_instance =
+      bridge_service->intent_helper()->GetInstanceForMethod(
+          "SendBroadcast", kSendBroadcastMinVersion);
+  if (intent_helper_instance) {
+    base::DictionaryValue extras;
+    extras.SetBoolean("inTouchMode",

[khmel, 2016/11/28 20:27:02]

Can we make sure that sequence of operations is correct?

For example we might have 2 app launch close to each other. One in touch mode
and second is not. Is is guaranty here that touch mode will be valid on the app
launch time?

Another concern:
App can be launched from Android itself. In this case last mode set from app
launcher will affect it.

[Luis Héctor Chávez, 2016/11/28 20:30:28]

I don't think such a guarantee is possible. Touch mode is a system-global state,
so the value of touch mode will be undefined for the first app.
Since touch mode is a system-global state, the app launched from Android itself
will preserve the value of touch mode from the first app. e.g. if the app was
launched using the keyboard, it will still be out of touch mode, regardless of
how the first app was invoked.

+                      ui::IsMouseEventFromFlags(event_flags) ||
+                          ui::IsTouchEventFromFlags(event_flags));
+    std::string extras_string;
+    base::JSONWriter::Write(extras, &extras_string);
+    intent_helper_instance->SendBroadcast(
+        "org.chromium.arc.intent_helper.SET_IN_TOUCH_MODE",
+        kIntentHelperPackageName, kIntentHelperClassName, extras_string);
+  }
+
   if (app_info->shortcut) {
     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;
 }
 
-bool LaunchAndroidSettingsApp(content::BrowserContext* context) {
+bool LaunchAndroidSettingsApp(content::BrowserContext* context,
+                              int event_flags) {
   constexpr bool kUseLandscapeLayout = true;
-  return arc::LaunchApp(context, kSettingsAppId, kUseLandscapeLayout);
-}
-
-bool LaunchApp(content::BrowserContext* context, const std::string& app_id) {
-  return LaunchApp(context, app_id, true);
+  return arc::LaunchApp(context, kSettingsAppId, kUseLandscapeLayout,
+                        event_flags);
 }
 
 bool LaunchApp(content::BrowserContext* context,
                const std::string& app_id,
-               bool landscape_layout) {
+               int event_flags) {
+  constexpr bool kUseLandscapeLayout = true;
+  return LaunchApp(context, app_id, kUseLandscapeLayout, event_flags);
+}
+
+bool LaunchApp(content::BrowserContext* context,
+               const std::string& app_id,
+               bool landscape_layout,
+               int event_flags) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(context);
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(app_id);
   if (app_info && !app_info->ready) {
     ArcSessionManager* arc_session_manager = ArcSessionManager::Get();
     DCHECK(arc_session_manager);
 
     bool arc_activated = false;
     if (!arc_session_manager->IsArcEnabled()) {
       if (!prefs->IsDefault(app_id)) {
         NOTREACHED();
@@ skipping 27 matching lines @@
         chromeos::SessionManagerClient* session_manager_client =
             chromeos::DBusThreadManager::Get()->GetSessionManagerClient();
         session_manager_client->PrioritizeArcInstance(
             base::Bind(PrioritizeArcInstanceCallback));
       }
     }
     prefs->SetLastLaunchTime(app_id, base::Time::Now());
     return true;
   }
 
-  return (new LaunchAppWithoutSize(context, app_id, landscape_layout))
+  return (new LaunchAppWithoutSize(context, app_id, landscape_layout,
+                                   event_flags))
       ->LaunchAndRelease();
 }
 
 void SetTaskActive(int task_id) {
   arc::mojom::AppInstance* app_instance =
       GetAppInstance(kTaskSupportMinVersion, kSetActiveTaskStr);
   if (!app_instance)
     return;
   app_instance->SetTaskActive(task_id);
 }
@@ skipping 13 matching lines @@
     return;
   }
 
   auto* intent_helper_instance =
       bridge_service->intent_helper()->GetInstanceForMethod(
           "SendBroadcast", kSendBroadcastMinVersion);
   if (!intent_helper_instance)
     return;
 
   intent_helper_instance->SendBroadcast(
-          "org.chromium.arc.intent_helper.SHOW_TALKBACK_SETTINGS",
-          "org.chromium.arc.intent_helper",
-          "org.chromium.arc.intent_helper.SettingsReceiver",
-          "{}");
+      "org.chromium.arc.intent_helper.SHOW_TALKBACK_SETTINGS",
+      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) {
@@ skipping 57 matching lines @@
   if (!app_instance)
     return false;
 
   app_instance->ShowPackageInfoOnPage(
       package_name, page,
       GetTargetRect(gfx::Size(kNexus7Width, kNexus7Height)));
   return true;
 }
 
 }  // namespace arc