arc-bridge: Implement IPC message for app launcher

components/arc/arc_bridge_service_impl.cc

 // Copyright 2015 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/arc_bridge_service_impl.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
@@ skipping 88 matching lines @@
                                                base::ScopedFD fd) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (state() != State::READY) {
     LOG(ERROR) << "Called RegisterInputDevice when the service is not ready";
     return false;
   }
   return ipc_channel_->Send(new ArcInstanceMsg_RegisterInputDevice(
       name, device_type, base::FileDescriptor(fd.Pass())));
 }
 
+bool ArcBridgeServiceImpl::RefreshApps() {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  if (state() != State::READY) {
+    LOG(ERROR) << "Called RefreshApps when the service is not ready";
+    return false;
+  }
+  return ipc_channel_->Send(new ArcInstanceMsg_RefreshApps());
+}
+
+bool ArcBridgeServiceImpl::LaunchApp(const std::string& package,
+                                     const std::string& activity) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  if (state() != State::READY) {
+    LOG(ERROR) << "Called LaunchApp when the service is not ready";
+    return false;
+  }
+
+  return ipc_channel_->Send(new ArcInstanceMsg_LaunchApp(package, activity));
+}
+
+bool ArcBridgeServiceImpl::RequestIcon(const std::string& package,
+                                       const std::string& activity,
+                                       int scale_factor) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  if (state() != State::READY) {
+    LOG(ERROR) << "Called RequestIcon when the service is not ready";
+    return false;
+  }
+  return ipc_channel_->Send(new ArcInstanceMsg_RequestIcon(package,
+                                                           activity,
+                                                           scale_factor));
+}
+
 void ArcBridgeServiceImpl::SocketConnect(const base::FilePath& socket_path) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (state() != State::STOPPED) {
     VLOG(1) << "SocketConnect() called when instance is not stopped";
     return;
   }
   SetState(State::CONNECTING);
   base::PostTaskAndReplyWithResult(
       file_task_runner_.get(), FROM_HERE,
       base::Bind(&base::CreateDirectory, socket_path.DirName()),
@@ skipping 96 matching lines @@
   FOR_EACH_OBSERVER(Observer, observer_list_, OnInstanceBootPhase(phase));
 }
 
 bool ArcBridgeServiceImpl::OnMessageReceived(const IPC::Message& message) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   bool handled = true;
 
   IPC_BEGIN_MESSAGE_MAP(ArcBridgeServiceImpl, message)
     IPC_MESSAGE_HANDLER(ArcInstanceHostMsg_InstanceBootPhase,
                         OnInstanceBootPhase)
+    IPC_MESSAGE_HANDLER(ArcInstanceHostMsg_AppsRefreshed, OnAppsRefreshed)
+    IPC_MESSAGE_HANDLER(ArcInstanceHostMsg_AppIcon, OnAppIcon)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!handled)
     LOG(ERROR) << "Invalid message with type = " << message.type();
   return handled;
 }
 
+void ArcBridgeServiceImpl::OnAppsRefreshed(
+    const std::vector<arc::AppInfo>& apps) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnAppsRefreshed(apps));
+}
+
+void ArcBridgeServiceImpl::OnAppIcon(const std::string& package,
+                                 const std::string& activity,
+                                 int scale_factor,
+                                 const std::vector<uint8_t>& icon_png_data) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnAppIcon(package,
+                                                        activity,
+                                                        scale_factor,
+                                                        icon_png_data));
+}
+
 void ArcBridgeServiceImpl::OnArcAvailable(bool arc_available) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (available() == arc_available)
     return;
   SetAvailable(arc_available);
   PrerequisitesChanged();
 }
 
 void ArcBridgeServiceImpl::OnInstanceStopped(bool success) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   // STOPPING is the only valid state for this function.
   // DCHECK on enum classes not supported.
   DCHECK(state() == State::STOPPING);
   ipc_channel_.reset();
   SetState(State::STOPPED);
 }
 
 }  // namespace arc