Implement permission_broker for serial devices.

device/serial/serial_io_handler_posix.cc

 // Copyright 2014 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 "device/serial/serial_io_handler_posix.h"
 
 #include <sys/ioctl.h>
 #include <termios.h>
 
 #include "base/posix/eintr_wrapper.h"
 
 #if defined(OS_LINUX)
 #include <linux/serial.h>
-#endif
+#if defined(OS_CHROMEOS)
+#include "base/bind.h"
+#include "base/sys_info.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/permission_broker_client.h"
+#endif  // defined(OS_CHROMEOS)
+#endif  // defined(OS_LINUX)
 
 namespace {
 
 // Convert an integral bit rate to a nominal one. Returns |true|
 // if the conversion was successful and |false| otherwise.
 bool BitrateToSpeedConstant(int bitrate, speed_t* speed) {
 #define BITRATE_TO_SPEED_CASE(x) \
   case x:                        \
     *speed = B##x;               \
     return true;
@@ skipping 91 matching lines @@
   return false;
 #endif
 }
 
 }  // namespace
 
 namespace device {
 
 // static
 scoped_refptr<SerialIoHandler> SerialIoHandler::Create(
-    scoped_refptr<base::MessageLoopProxy> file_thread_message_loop) {
-  return new SerialIoHandlerPosix(file_thread_message_loop);
+    scoped_refptr<base::MessageLoopProxy> file_thread_message_loop,
+    scoped_refptr<base::MessageLoopProxy> ui_thread_message_loop) {
+  return new SerialIoHandlerPosix(file_thread_message_loop,
+                                  ui_thread_message_loop);
+}
+
+void SerialIoHandlerPosix::RequestAccess(
+    const std::string& port,
+    scoped_refptr<base::MessageLoopProxy> file_message_loop,
+    scoped_refptr<base::MessageLoopProxy> ui_message_loop) {
+#if defined(OS_LINUX) && defined(OS_CHROMEOS)
+  if (base::SysInfo::IsRunningOnChromeOS()) {
+    chromeos::PermissionBrokerClient* client =
+        chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
+    if (!client) {
+      DVLOG(1) << "Could not get permission_broker client.";
+      OnRequestAccessComplete(port, false /* failure */);
+      return;
+    }
+    // PermissionBrokerClient should be called on the UI thread.
+    ui_message_loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &chromeos::PermissionBrokerClient::RequestPathAccess,
+            base::Unretained(client),
+            port,
+            -1,
+            base::Bind(&SerialIoHandler::OnRequestAccessComplete, this, port)));
+  } else {
+    OnRequestAccessComplete(port, true /* success */);
+    return;
+  }
+#else
+  OnRequestAccessComplete(port, true /* success */);
+#endif  // defined(OS_LINUX) && defined(OS_CHROMEOS)
 }
 
 void SerialIoHandlerPosix::ReadImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_read_buffer());
   DCHECK(file().IsValid());
 
   EnsureWatchingReads();
 }
 
@@ skipping 13 matching lines @@
 }
 
 void SerialIoHandlerPosix::CancelWriteImpl() {
   DCHECK(CalledOnValidThread());
   is_watching_writes_ = false;
   file_write_watcher_.StopWatchingFileDescriptor();
   QueueWriteCompleted(0, write_cancel_reason());
 }
 
 SerialIoHandlerPosix::SerialIoHandlerPosix(
-    scoped_refptr<base::MessageLoopProxy> file_thread_message_loop)
-    : SerialIoHandler(file_thread_message_loop),
+    scoped_refptr<base::MessageLoopProxy> file_thread_message_loop,
+    scoped_refptr<base::MessageLoopProxy> ui_thread_message_loop)
+    : SerialIoHandler(file_thread_message_loop, ui_thread_message_loop),
       is_watching_reads_(false),
       is_watching_writes_(false) {
 }
 
 SerialIoHandlerPosix::~SerialIoHandlerPosix() {
 }
 
 void SerialIoHandlerPosix::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(fd, file().GetPlatformFile());
@@ skipping 230 matching lines @@
       (config.c_cflag & CSTOPB) ? serial::STOP_BITS_TWO : serial::STOP_BITS_ONE;
   info->cts_flow_control = (config.c_cflag & CRTSCTS) != 0;
   return info.Pass();
 }
 
 std::string SerialIoHandler::MaybeFixUpPortName(const std::string& port_name) {
   return port_name;
 }
 
 }  // namespace device