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 "base/macros.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 49 matching lines @@
   };
 
   class Observer {
    public:
     // Called whenever the state of the bridge has changed.
     virtual void OnStateChanged(State state) {}
 
     // Called whenever ARC's availability has changed for this system.
     virtual void OnAvailableChanged(bool available) {}
 
+    // Called whenever to create video accelerator connection.
+    virtual void OnCreateArcVideoAcceleratorConnection() {}

[Owen Lin, 2015/12/07 09:05:23]

How about rename it as OnRequestArcVideoAcceleratorConnection()?
// Called whenever there is a request to create a video accelerator connection.

In addition, Should we use the observer pattern to support the function?
Observer sounds like an optional. But it is not the case.

How about a ConnectionProvider or ConnectionFactory?

For example:

class ArcBridgeService {
public:
  class ConnectionProvider {
    IPC::ChannelHandle buildConnection();
  };

  bool requestConnection(enum ConnectionType, IPC::ChannelHandle &output) {
  }

  void registerConnectionProvider(ConnectionType, ConnectionProvider) {
  }
};

[kcwu, 2015/12/10 10:17:37]

Revised to use new ArcBridgeService's new observer. PTAL.

+
    protected:
     virtual ~Observer() {}
   };
 
   ArcBridgeService(
       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner,
       const scoped_refptr<base::SequencedTaskRunner>& file_task_runner);
   ~ArcBridgeService() override;
 
   // Gets the global instance of the ARC Bridge Service. This can only be
@@ skipping 28 matching lines @@
   // 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")
   // and |fd| a file descriptor that emulates the kernel events of the device.
   // This can only be called on the thread that this class was created on.
   bool RegisterInputDevice(const std::string& name,
                            const std::string& device_type,
                            base::ScopedFD fd);
 
+  bool NotifyVideoAcceleratorConnectionCreated(IPC::ChannelHandle handle);
+
  private:
   friend class ArcBridgeTest;
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, Basic);
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, ShutdownMidStartup);
 
   // If all pre-requisites are true (ARC is available, it has been enabled, and
   // the session has started), and ARC is stopped, start ARC. If ARC is running
   // and the pre-requisites stop being true, stop ARC.
   void PrerequisitesChanged();
 
@@ skipping 13 matching lines @@
   void SocketConnectAfterSetSocketPermissions(const base::FilePath& socket_path,
                                               bool socket_permissions_success);
 
   // Stops the running instance.
   void StopInstance();
 
   // Called when the ARC instance has finished setting up and is ready for user
   // interaction.
   void OnInstanceReady();
 
+  void OnCreateArcVideoAcceleratorConnection();
+
   // Changes the current state and notifies all observers.
   void SetState(State state);
 
   // IPC::Listener:
   bool OnMessageReceived(const IPC::Message& message) override;
 
   // DBus callbacks.
   void OnArcAvailable(bool available);
   void OnInstanceStarted(bool success);
   void OnInstanceStopped(bool success);
@@ skipping 17 matching lines @@
 
   // WeakPtrFactory to use callbacks.
   base::WeakPtrFactory<ArcBridgeService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcBridgeService);
 };
 
 }  // namespace arc
 
 #endif  // COMPONENTS_ARC_ARC_BRIDGE_SERVICE_H_