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

device/hid/hid_service_linux.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/hid/hid_service_linux.h"
 
 #include <fcntl.h>
 #include <stdint.h>
 #include <limits>
 #include <string>
@@ skipping 223 matching lines @@
   scoped_refptr<HidDeviceInfoLinux> device_info =
       static_cast<HidDeviceInfoLinux*>(map_entry->second.get());
 
   scoped_ptr<ConnectParams> params(new ConnectParams(
       device_info, callback, task_runner_, file_task_runner_));
 
 #if defined(OS_CHROMEOS)
   chromeos::PermissionBrokerClient* client =
       chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
   DCHECK(client) << "Could not get permission broker client.";
+  chromeos::PermissionBrokerClient::ErrorCallback error_callback =
+      base::Bind(&HidServiceLinux::OnPathOpenError,
+                 params->device_info->device_node(), params->callback);
   client->OpenPath(
       device_info->device_node(),
-      base::Bind(&HidServiceLinux::OnPathOpened, base::Passed(&params)));
+      base::Bind(&HidServiceLinux::OnPathOpenComplete, base::Passed(&params)),
+      error_callback);
 #else
   file_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&HidServiceLinux::OpenOnBlockingThread,
                                          base::Passed(&params)));
 #endif  // defined(OS_CHROMEOS)
 }
 
 #if defined(OS_CHROMEOS)
 
 // static
-void HidServiceLinux::OnPathOpened(scoped_ptr<ConnectParams> params,
-                                   dbus::FileDescriptor fd) {
+void HidServiceLinux::OnPathOpenComplete(scoped_ptr<ConnectParams> params,
+                                         dbus::FileDescriptor fd) {
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       params->file_task_runner;
   file_task_runner->PostTask(
       FROM_HERE, base::Bind(&HidServiceLinux::ValidateFdOnBlockingThread,
                             base::Passed(&params), base::Passed(&fd)));
 }
 
 // static
+void HidServiceLinux::OnPathOpenError(const std::string& device_path,
+                                      const ConnectCallback& callback,
+                                      const std::string& error_name,
+                                      const std::string& error_message) {
+  HID_LOG(EVENT) << "Permission broker failed to open '" << device_path
+                 << "': " << error_name << ": " << error_message;
+  callback.Run(nullptr);
+}
+
+// static
 void HidServiceLinux::ValidateFdOnBlockingThread(
     scoped_ptr<ConnectParams> params,
     dbus::FileDescriptor fd) {
   base::ThreadRestrictions::AssertIOAllowed();
-
   fd.CheckValidity();
-  if (fd.is_valid()) {
-    params->device_file = base::File(fd.TakeValue());
-    FinishOpen(std::move(params));
-  } else {
-    HID_LOG(EVENT) << "Permission broker denied access to '"
-                   << params->device_info->device_node() << "'.";
-    params->task_runner->PostTask(FROM_HERE,
-                                  base::Bind(params->callback, nullptr));
-  }
+  DCHECK(fd.is_valid());
+  params->device_file = base::File(fd.TakeValue());
+  FinishOpen(std::move(params));
 }
 
 #else
 
 // static
 void HidServiceLinux::OpenOnBlockingThread(scoped_ptr<ConnectParams> params) {
   base::ThreadRestrictions::AssertIOAllowed();
   scoped_refptr<base::SingleThreadTaskRunner> task_runner = params->task_runner;
 
   base::FilePath device_path(params->device_info->device_node());
@@ skipping 42 matching lines @@
 
 // static
 void HidServiceLinux::CreateConnection(scoped_ptr<ConnectParams> params) {
   DCHECK(params->device_file.IsValid());
   params->callback.Run(make_scoped_refptr(new HidConnectionLinux(
       params->device_info, std::move(params->device_file),
       params->file_task_runner)));
 }
 
 }  // namespace device