Implement GpuArcVideoService for arc video accelerator

components/arc/arc_bridge_service.h

 // 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.
 
 #ifndef COMPONENTS_ARC_ARC_BRIDGE_SERVICE_H_
 #define COMPONENTS_ARC_ARC_BRIDGE_SERVICE_H_
 
 #include <string>
 #include <vector>
 
 #include "base/files/scoped_file.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "components/arc/common/arc_bridge.mojom.h"
 
 namespace base {
 class CommandLine;
 }  // namespace base
 
+namespace IPC {
+class ChannelHandle;
+}  // namespace IPC
+
 namespace arc {
 
 class ArcBridgeBootstrap;
 
 // The Chrome-side service that handles ARC instances and ARC bridge creation.
 // This service handles the lifetime of ARC instances and sets up the
 // communication channel (the ARC bridge) used to send and receive messages.
 class ArcBridgeService {
  public:
   // The possible states of the bridge.  In the normal flow, the state changes
@@ skipping 89 matching lines @@
     // Do not use the process list obtained here for security-sensitive purpose.
     // Good news is that Android processes are designed to be ready to be killed
     // at any time, so killing a wrong process is not a disaster.
     virtual void OnUpdateProcessList(
         const std::vector<RunningAppProcessInfo>& processes) {}
 
    protected:
     virtual ~ProcessObserver() {}
   };
 
+  // Notifies ARC video service events.
+  class VideoService {
+   public:
+    // Called whenever to create video accelerator connection.
+    virtual void OnRequestArcVideoAcceleratorChannel() {}
+
+   protected:
+    virtual ~VideoService() {}
+  };
+
   virtual ~ArcBridgeService();
 
   // Gets the global instance of the ARC Bridge Service. This can only be
   // called on the thread that this class was created on.
   static ArcBridgeService* Get();
 
   // Return true if ARC has been enabled through a commandline
   // switch.
   static bool GetEnabled(const base::CommandLine* command_line);
 
@@ skipping 21 matching lines @@
   // Adds or removes ARC app observers. This can only be called on the thread
   // that this class was created on.
   void AddAppObserver(AppObserver* observer);
   void RemoveAppObserver(AppObserver* observer);
 
   // Adds or removes ARC process observers. This can only be called on the
   // thread that this class was created on.
   void AddProcessObserver(ProcessObserver* observer);
   void RemoveProcessObserver(ProcessObserver* observer);
 
+  // Set VideoService provider. This can only be called on the thread that
+  // this class was created on.
+  void SetVideoService(VideoService* service);
+
   // Gets the current state of the bridge service.
   State state() const { return state_; }
 
   // Gets if ARC is available in this system.
   bool available() const { return available_; }
 
   // Requests registration of an input device on the ARC instance.
   // TODO(denniskempin): Make this interface more typesafe.
   // |name| should be the displayable name of the emulated device (e.g. "Chrome
   // OS Keyboard"), |device_type| the name of the device type (e.g. "keyboard")
@@ skipping 16 matching lines @@
 
   // Requests to load an icon of specific scale_factor.
   virtual bool RequestAppIcon(const std::string& package,
                               const std::string& activity,
                               ScaleFactor scale_factor) = 0;
 
   // Requests a list of processes from the ARC instance.
   // When the result comes back, Observer::OnUpdateProcessList() is called.
   virtual bool RequestProcessList() = 0;
 
+  // Notify the ipc handle for video accelerator is created.
+  virtual void NotifyVideoAcceleratorChannelCreated(
+      const IPC::ChannelHandle& handle) = 0;
+
  protected:
   ArcBridgeService();
 
   // Changes the current state and notifies all observers.
   void SetState(State state);
 
   // Changes the current availability and notifies all observers.
   void SetAvailable(bool availability);
 
   base::ObserverList<Observer>& observer_list() { return observer_list_; }
 
   base::ObserverList<NotificationObserver>& notification_observer_list() {
     return notification_observer_list_;
   }
 
   base::ObserverList<AppObserver>& app_observer_list() {
     return app_observer_list_;
   }
 
   base::ObserverList<ProcessObserver>& process_observer_list() {
     return process_observer_list_;
   }
 
+  VideoService* video_service() { return video_service_; }
+
   bool CalledOnValidThread();
 
  private:
   friend class ArcBridgeTest;
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, Basic);
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, Prerequisites);
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, ShutdownMidStartup);
 
   base::ObserverList<Observer> observer_list_;
   base::ObserverList<NotificationObserver> notification_observer_list_;
   base::ObserverList<AppObserver> app_observer_list_;
   base::ObserverList<ProcessObserver> process_observer_list_;
 
+  VideoService* video_service_;
+
   base::ThreadChecker thread_checker_;
 
   // If the ARC instance service is available.
   bool available_;
 
   // The current state of the bridge.
   ArcBridgeService::State state_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcBridgeService);
 };
 
 }  // namespace arc
 
 #endif  // COMPONENTS_ARC_ARC_BRIDGE_SERVICE_H_