Add IPC messages for ARC notification

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"
+#include "components/arc/common/arc_notification_types.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 
 namespace arc {
 
 // 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 IPC::Listener {
@@ skipping 39 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 a notification has been posted on Android side. This
+    // event is used for both creation and update.
+    virtual void OnNotificationPostedFromAndroid(
+        const ArcNotificationData& data) {}
+    // Called whenever a notification has been removed on Android side.
+    virtual void OnNotificationRemovedFromAndroid(const std::string& key) {}
+
    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);
 
+  // Notifys a notification event to Android side.

[hidehiko, 2015/11/26 10:47:09]

nit: Notifies.

[yoshiki, 2015/11/27 10:48:06]

Done.

+  bool NotifyNotificationEvent(const std::string& key, NotificationEvent event);
+
  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();
 
+  // Handler for ArcInstanceHostMsg_NotificationPosted message.
+  void OnNotificationPosted(const ArcNotificationData& data);
+  // Handler for ArcInstanceHostMsg_NotificationRemoved message.
+  void OnNotificationRemoved(const std::string& key);
+
   // 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_