Add IPC messages for ARC notification

components/arc/arc_bridge_service.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.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 116 matching lines @@
                                            base::ScopedFD fd) {
   DCHECK(ipc_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 ArcBridgeService::NotifyNotificationEvent(const std::string& key,

[elijahtaylor1, 2015/11/27 05:42:49]

"NotifyNotification" is kind of confusing to put together, and it's not clear
from this method name the direction of things.  Maybe,
SendNotificationEventToAndroid?

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

Done.

+                                               NotificationEvent event) {
+  DCHECK(ipc_task_runner_->RunsTasksOnCurrentThread());
+  if (state_ != State::READY) {
+    LOG(ERROR) << "Called RegisterInputDevice when the service is not ready";

[elijahtaylor1, 2015/11/27 05:42:49]

copy/paste error with RegisterInputDevice

Maybe we should wait for the mojo switch, but we could probably reduce some of
the boilerplate here by centralizing state/method checking to make sure we're in
a consistent state

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

I created a SendMessageIfReady(Message*) method, which sends a message only if
it's ready. How about this?

+    return false;
+  }
+  if (key.empty()) {
+    LOG(ERROR) << "NotifyNotificationEvent failed: Wrong parameter";
+    return false;
+  }
+  return ipc_channel_->Send(
+      new ArcInstanceMsg_NotifyNotificationEvent(key, event));
+}
+
 void ArcBridgeService::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 86 matching lines @@
 
 void ArcBridgeService::OnInstanceReady() {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (state_ != State::STARTING) {
     VLOG(1) << "StopInstance() called while connecting";
     return;
   }
   SetState(State::READY);
 }
 
+void ArcBridgeService::OnNotificationPosted(
+    const arc::ArcNotificationData& data) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  FOR_EACH_OBSERVER(Observer, observer_list_,
+                    OnNotificationPostedFromAndroid(data));
+}
+
+void ArcBridgeService::OnNotificationRemoved(const std::string& key) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  FOR_EACH_OBSERVER(Observer, observer_list_,
+                    OnNotificationRemovedFromAndroid(key));
+}
+
 void ArcBridgeService::SetState(State state) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   // DCHECK on enum classes not supported.
   DCHECK(state_ != state);
   state_ = state;
   FOR_EACH_OBSERVER(Observer, observer_list_, OnStateChanged(state_));
 }
 
 bool ArcBridgeService::OnMessageReceived(const IPC::Message& message) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   bool handled = true;
 
   IPC_BEGIN_MESSAGE_MAP(ArcBridgeService, message)
     IPC_MESSAGE_HANDLER(ArcInstanceHostMsg_InstanceReady, OnInstanceReady)
+    IPC_MESSAGE_HANDLER(ArcInstanceHostMsg_NotificationPosted,
+                        OnNotificationPosted)
+    IPC_MESSAGE_HANDLER(ArcInstanceHostMsg_NotificationRemoved,
+                        OnNotificationRemoved)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!handled)
     LOG(ERROR) << "Invalid message with type = " << message.type();
   return handled;
 }
 
 void ArcBridgeService::OnArcAvailable(bool available) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (available_ == available)
     return;
   available_ = available;
   FOR_EACH_OBSERVER(Observer, observer_list_, OnAvailableChanged(available_));
   PrerequisitesChanged();
 }
 
 void ArcBridgeService::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