Add path open errors from the permission broker to the device log.

device/serial/serial_io_handler.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.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 36 matching lines @@
   DCHECK(file_thread_task_runner_.get());
   DCHECK(ui_thread_task_runner_.get());
   MergeConnectionOptions(options);
   port_ = port;
 
 #if defined(OS_CHROMEOS)
   chromeos::PermissionBrokerClient* client =
       chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
   DCHECK(client) << "Could not get permission_broker client.";
   // PermissionBrokerClient should be called on the UI thread.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      base::ThreadTaskRunnerHandle::Get();
   ui_thread_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&chromeos::PermissionBrokerClient::OpenPath,
-                            base::Unretained(client), port,
-                            base::Bind(&SerialIoHandler::OnPathOpened, this,
-                                       file_thread_task_runner_,
-                                       base::ThreadTaskRunnerHandle::Get())));
+      FROM_HERE,
+      base::Bind(
+          &chromeos::PermissionBrokerClient::OpenPath, base::Unretained(client),
+          port, base::Bind(&SerialIoHandler::OnPathOpened, this,
+                           file_thread_task_runner_, task_runner),
+          base::Bind(&SerialIoHandler::OnPathOpenError, this, task_runner)));
 #else
   file_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SerialIoHandler::StartOpen, this, port,
                             base::ThreadTaskRunnerHandle::Get()));
 #endif  // defined(OS_CHROMEOS)
 }
 
 #if defined(OS_CHROMEOS)
 
 void SerialIoHandler::OnPathOpened(
     scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
     dbus::FileDescriptor fd) {
-  DCHECK(CalledOnValidThread());
   file_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&SerialIoHandler::ValidateOpenPort, this,
                             io_thread_task_runner, base::Passed(&fd)));
 }
 
+void SerialIoHandler::OnPathOpenError(
+    scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
+    const std::string& error_name,
+    const std::string& error_message) {
+  io_thread_task_runner->PostTask(
+      FROM_HERE, base::Bind(&SerialIoHandler::ReportPathOpenError, this,
+                            error_name, error_message));
+}
+
 void SerialIoHandler::ValidateOpenPort(
     scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
     dbus::FileDescriptor fd) {
   base::File file;
   fd.CheckValidity();
   if (fd.is_valid()) {
     file = base::File(fd.TakeValue());
   }
 
   io_thread_task_runner->PostTask(
       FROM_HERE,
       base::Bind(&SerialIoHandler::FinishOpen, this, base::Passed(&file)));
 }
 
+void SerialIoHandler::ReportPathOpenError(const std::string& error_name,
+                                          const std::string& error_message) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!open_complete_.is_null());
+  LOG(ERROR) << "Permission broker failed to open '" << port_
+             << "': " << error_name << ": " << error_message;
+  OpenCompleteCallback callback = open_complete_;
+  open_complete_.Reset();
+  callback.Run(false);
+}
+
 #endif
 
 void SerialIoHandler::MergeConnectionOptions(
     const serial::ConnectionOptions& options) {
   if (options.bitrate) {
     options_.bitrate = options.bitrate;
   }
   if (options.data_bits != serial::DataBits::NONE) {
     options_.data_bits = options.data_bits;
   }
@@ skipping 158 matching lines @@
 }
 
 void SerialIoHandler::QueueWriteCompleted(int bytes_written,
                                           serial::SendError error) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&SerialIoHandler::WriteCompleted, this, bytes_written, error));
 }
 
 }  // namespace device