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

chromeos/dbus/fake_permission_broker_client.cc

 // Copyright 2013 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 "chromeos/dbus/fake_permission_broker_client.h"
 
 #include <fcntl.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "dbus/file_descriptor.h"
 
 namespace chromeos {
 
 namespace {
 
 // So that real devices can be accessed by tests and "Chromium OS on Linux" this
 // function implements a simplified version of the method implemented by the
 // permission broker by opening the path specified and returning the resulting
 // file descriptor.
 void OpenPathAndValidate(
     const std::string& path,
     const PermissionBrokerClient::OpenPathCallback& callback,
+    const PermissionBrokerClient::ErrorCallback& error_callback,
     scoped_refptr<base::TaskRunner> task_runner) {
-  dbus::FileDescriptor dbus_fd;
   int fd = HANDLE_EINTR(open(path.c_str(), O_RDWR));
   if (fd < 0) {
-    PLOG(WARNING) << "Failed to open '" << path << "'";
+    int error_code = logging::GetLastSystemErrorCode();
+    task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(error_callback, "open_failed",

[stevenjb, 2016/02/09 23:16:51]

nit: define 'open_failed' as a const, make available in header

[Reilly Grant (use Gerrit), 2016/02/09 23:54:03]

Which header do you recommend? permission_broker_client.h or
service_constants.h? Ideally these errors would be part of the interface exposed
by the permission broker service.

[stevenjb, 2016/02/10 00:01:01]

Oh, I didn't notice this was the fake. In that case feel free to ignore this,
otherwise we should use the same const that the real implementation uses if
available, or define that as a const in this file.

[Reilly Grant (use Gerrit), 2016/02/10 00:16:32]

Done.

+                   base::StringPrintf(
+                       "Failed to open '%s': %s", path.c_str(),
+                       logging::SystemErrorCodeToString(error_code).c_str())));

[stevenjb, 2016/02/09 23:16:51]

nit: return here, remove else

[Reilly Grant (use Gerrit), 2016/02/10 00:16:32]

Done.

   } else {
+    dbus::FileDescriptor dbus_fd;
     dbus_fd.PutValue(fd);
     dbus_fd.CheckValidity();
+    task_runner->PostTask(FROM_HERE,
+                          base::Bind(callback, base::Passed(&dbus_fd)));
   }
-  task_runner->PostTask(FROM_HERE,
-                        base::Bind(callback, base::Passed(&dbus_fd)));
 }
 
 }  // namespace
 
 FakePermissionBrokerClient::FakePermissionBrokerClient() {}
 
 FakePermissionBrokerClient::~FakePermissionBrokerClient() {}
 
 void FakePermissionBrokerClient::Init(dbus::Bus* bus) {}
 
 void FakePermissionBrokerClient::CheckPathAccess(
     const std::string& path,
     const ResultCallback& callback) {
   callback.Run(true);
 }
 
 void FakePermissionBrokerClient::OpenPath(const std::string& path,
-                                          const OpenPathCallback& callback) {
-  base::WorkerPool::PostTask(FROM_HERE,
-                             base::Bind(&OpenPathAndValidate, path, callback,
-                                        base::ThreadTaskRunnerHandle::Get()),
-                             false);
+                                          const OpenPathCallback& callback,
+                                          const ErrorCallback& error_callback) {
+  base::WorkerPool::PostTask(
+      FROM_HERE,
+      base::Bind(&OpenPathAndValidate, path, callback, error_callback,
+                 base::ThreadTaskRunnerHandle::Get()),
+      false);
 }
 
 void FakePermissionBrokerClient::RequestTcpPortAccess(
     uint16_t port,
     const std::string& interface,
     const dbus::FileDescriptor& lifeline_fd,
     const ResultCallback& callback) {
   DCHECK(lifeline_fd.is_valid());
   callback.Run(true);
 }
@@ skipping 15 matching lines @@
 }
 
 void FakePermissionBrokerClient::ReleaseUdpPort(
     uint16_t port,
     const std::string& interface,
     const ResultCallback& callback) {
   callback.Run(true);
 }
 
 }  // namespace chromeos