chromeos: Add ArcInputBridge to components/arc

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 19 matching lines @@
 ArcBridgeService::ArcBridgeService(
     const scoped_refptr<base::SequencedTaskRunner>& file_task_runner)
   : ipc_thread_("ARC bridge listener"),
     origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
     file_task_runner_(file_task_runner),
     observer_list_(new base::ObserverListThreadSafe<Observer>()),
     available_(false),
     enabled_(false),
     state_(ArcBridgeService::STOPPED),
     weak_factory_(this) {
+  LOG(ERROR) << "[ARC] ArcBridgeService";

[elijahtaylor1, 2015/11/02 22:30:29]

is it appropriate to log to the error channel these messages? I would think INFO
a better choice

[denniskempin, 2015/11/16 18:39:28]

This was just for debugging. I removed them again.

   ipc_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 }
 
 ArcBridgeService::~ArcBridgeService() {}
 
 // static
 void ArcBridgeService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kArcEnabled, false);
 }
 
 // static
 bool ArcBridgeService::GetEnabledPref(PrefService* pref_service) {
   // TODO(lhchavez): Once this is user-configurable, use the real pref.
   return true;
 }
 
 void ArcBridgeService::HandleStartup() {
+  LOG(ERROR) << "[ARC] HandleStartup";
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (!enabled_)
     return;
   SocketConnect(base::FilePath(kArcBridgeSocketPath));
 }
 
 void ArcBridgeService::Shutdown() {
+  LOG(ERROR) << "[ARC] Shutdown";
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (state_ == ArcBridgeService::STOPPED ||
       state_ == ArcBridgeService::STOPPING) {
     LOG(ERROR) << "Shutdown() called when ARC is not running";
     return;
   }
   SetState(ArcBridgeService::STOPPING);
+
+  // Destroying the BridgeDevices will close their file descriptors, which will
+  // cause the corresponding devices on the instance-side to be destroyed as

[elijahtaylor1, 2015/11/02 22:30:29]

how is this guaranteed?  do failed reads cause the devices to be deleted?

[denniskempin, 2015/11/16 18:39:28]

Yes, the EventHub will close devices in two conditions:
- INotify noticed that the /dev/input/ node has been removed.
- The fd read returns 0 (EOF) or errno=ENODEV.
When the write end of the pipe is being closed, the read end will return EOF.

+  // well.
+  bridge_devices_.clear();
+
   ipc_channel_->Close();
   ipc_channel_.reset();
   base::PostTaskAndReplyWithResult(
       file_task_runner_.get(),
       FROM_HERE,
       base::Bind(&base::DeleteFile, base::FilePath(kArcBridgeSocketPath),
                  false),
       base::Bind(&ArcBridgeService::FinishShutdownAfterSocketDeleted,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 13 matching lines @@
     return;
   enabled_ = enabled;
   if (!enabled_ && state_ != ArcBridgeService::STOPPED &&
       state_ != ArcBridgeService::STOPPING)
     Shutdown();
   observer_list_->Notify(FROM_HERE,
                          &Observer::OnEnabledChanged,
                          enabled_);
 }
 
-bool ArcBridgeService::RegisterInputDevice(
-    const std::string& name, const std::string& device_type,
-    base::ScopedFD fd) {
-  // ipc_channel_->Send() is thread-safe, so there is no thread check.
-  if (state_ != ArcBridgeService::READY) {
-    LOG(ERROR) << "Called RegisterInputDevice when the service is not ready";
-    return false;
+base::ScopedFD ArcBridgeService::CreateBridgeInputDevice(
+    const std::string& name, const std::string& device_type) {
+  LOG(ERROR) << "[ARC] CreateBridgeInputDevice";
+
+  // Create file descriptor pair for communication
+  int fd[2];
+  if (pipe(fd) < 0) {
+    LOG(ERROR) << "Cannot create pipe: " << strerror(errno);

[elijahtaylor1, 2015/11/02 22:30:29]

https://code.google.com/p/chromium/codesearch#chromium/src/base/posix/safe_st...

Please see if there is a better replacement for strerror.

[denniskempin, 2015/11/16 18:39:28]

Done. PLOG does automatically append the error description :)

   }
-  return ipc_channel_->Send(new ArcInstanceMsg_RegisterInputDevice(
-        name, device_type, base::FileDescriptor(fd.Pass())));
+
+  // The read end is sent to the instance
+  ipc_channel_->Send(new ArcInstanceMsg_RegisterInputDevice(
+        name, device_type, base::FileDescriptor(fd[0], true)));
+
+  // return the write end
+  return base::ScopedFD(fd[1]);
+}
+
+void ArcBridgeService::SetupBridgeInputDevices() {
+  bridge_devices_.push_back(new TouchscreenBridgeInputDevice(
+      CreateBridgeInputDevice("ChromeOS Touchscreen", "touchscreen")));
 }
 
 void ArcBridgeService::SocketConnect(const base::FilePath& socket_path) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  LOG(ERROR) << "[ARC] SocketConnect";
+
   if (state_ != ArcBridgeService::STOPPED) {
     LOG(ERROR) << "SocketConnect() called when instance is not stopped";
     return;
   }
   SetState(ArcBridgeService::CONNECTING);
   base::PostTaskAndReplyWithResult(
       file_task_runner_.get(),
       FROM_HERE,
       base::Bind(&base::CreateDirectory, socket_path.DirName()),
       base::Bind(&ArcBridgeService::SocketConnectAfterEnsureParentDirectory,
                  weak_factory_.GetWeakPtr(),
                  socket_path));
 }
 
+
 void ArcBridgeService::SocketConnectAfterEnsureParentDirectory(
     const base::FilePath& socket_path, bool directory_present) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (state_ != ArcBridgeService::CONNECTING) {
     LOG(ERROR) << "Shutdown requested while connecting";
     return;
   }
   if (!directory_present) {
     LOG(ERROR) << "Error creating directory for " << socket_path.value();
     Shutdown();
@@ skipping 42 matching lines @@
 bool ArcBridgeService::Connect(const IPC::ChannelHandle& handle,
                                IPC::Channel::Mode mode) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   // Testing code can have the state in STOPPED since it does not go through
   // the whole connection flow.
   if (state_ != ArcBridgeService::CONNECTING &&
       state_ != ArcBridgeService::STOPPED) {
     LOG(ERROR) << "Shutdown requested while connecting";
     return false;
   }
+  LOG(ERROR) << "[ARC] Connect";
 
   ipc_channel_ = IPC::ChannelProxy::Create(handle, mode, this,
                                            ipc_thread_.task_runner().get());
   if (!ipc_channel_)
     return false;
   SetState(ArcBridgeService::CONNECTED);
   return true;
 }
 
 void ArcBridgeService::OnInstanceReady() {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (state_ != ArcBridgeService::CONNECTED) {
     LOG(ERROR) << "Shutdown requested while connecting";
     return;
   }
+  LOG(ERROR) << "[ARC] OnInstanceReady";
+  SetupBridgeInputDevices();
   SetState(ArcBridgeService::READY);
 }
 
 void ArcBridgeService::SetState(State state) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   if (state_ == state)
     return;
   state_ = state;
   observer_list_->Notify(FROM_HERE,
                          &Observer::OnStateChanged,
@@ skipping 19 matching lines @@
   IPC_END_MESSAGE_MAP()
 
   if (!handled)
     LOG(ERROR) << "Invalid message with type = " << message.type();
   return handled;
 }
 
 void ArcBridgeService::OnInstanceStarted(
     chromeos::DBusMethodCallStatus status) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  LOG(ERROR) << "[ARC] OnInstanceStarted";
   if (state_ != ArcBridgeService::CONNECTED) {
     LOG(ERROR) << "Shutdown requested while connecting";
     return;
   }
   if (status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
     LOG(ERROR) << "ARC instance unable to start. Shutting down the bridge";
     Shutdown();
     return;
   }
   SetState(ArcBridgeService::STARTING);
 }
 
 void ArcBridgeService::OnInstanceStopped(
     chromeos::DBusMethodCallStatus status) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   // STOPPING is the only valid state for this function.
   CHECK(state_ == ArcBridgeService::STOPPING);
   SetState(ArcBridgeService::STOPPED);
 }
 
 }  // namespace arc