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

chromeos/dbus/permission_broker_client.cc

 // Copyright (c) 2012 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/permission_broker_client.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
                        const ResultCallback& callback) override {
     dbus::MethodCall method_call(kPermissionBrokerInterface, kCheckPathAccess);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(path);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&PermissionBrokerClientImpl::OnResponse,
                                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void OpenPath(const std::string& path,
-                const OpenPathCallback& callback) override {
+                const OpenPathCallback& callback,
+                const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(kPermissionBrokerInterface, kOpenPath);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(path);
-    proxy_->CallMethod(
+    proxy_->CallMethodWithErrorCallback(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&PermissionBrokerClientImpl::OnOpenPathResponse,
-                   weak_ptr_factory_.GetWeakPtr(), callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback),
+        base::Bind(&PermissionBrokerClientImpl::OnError,
+                   weak_ptr_factory_.GetWeakPtr(), error_callback));
   }
 
   void RequestTcpPortAccess(uint16_t port,
                             const std::string& interface,
                             const dbus::FileDescriptor& lifeline_fd,
                             const ResultCallback& callback) override {
     dbus::MethodCall method_call(kPermissionBrokerInterface,
                                  kRequestTcpPortAccess);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint16(port);
@@ skipping 63 matching lines @@
     bool result = false;
     dbus::MessageReader reader(response);
     if (!reader.PopBool(&result))
       LOG(WARNING) << "Could not parse response: " << response->ToString();
     callback.Run(result);
   }
 
   void OnOpenPathResponse(const OpenPathCallback& callback,
                           dbus::Response* response) {
     dbus::FileDescriptor fd;
-    if (response) {
-      dbus::MessageReader reader(response);
-      if (!reader.PopFileDescriptor(&fd))
-        LOG(WARNING) << "Could not parse response: " << response->ToString();
-    } else {
-      LOG(WARNING) << "Access request method call failed.";
-    }
-
+    dbus::MessageReader reader(response);
+    if (!reader.PopFileDescriptor(&fd))
+      LOG(WARNING) << "Could not parse response: " << response->ToString();
     callback.Run(std::move(fd));
   }
 
+  void OnError(const ErrorCallback& callback, dbus::ErrorResponse* response) {
+    std::string error_name;
+    std::string error_message;
+    if (response) {
+      dbus::MessageReader reader(response);
+      error_name = response->GetErrorName();
+      reader.PopString(&error_message);
+    } else {
+      error_name = "org.chromium.Error.NoResponse";

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

nit: define at the top of the file:

const char kNoResponseError[] = "org.chromium.Error.NoResponse"; 

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

Done.

+    }
+    callback.Run(error_name, error_message);
+  }
+
   dbus::ObjectProxy* proxy_;
 
   // Note: This should remain the last member so that it will be destroyed
   // first, invalidating its weak pointers, before the other members are
   // destroyed.
   base::WeakPtrFactory<PermissionBrokerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionBrokerClientImpl);
 };
 
 PermissionBrokerClient::PermissionBrokerClient() {}
 
 PermissionBrokerClient::~PermissionBrokerClient() {}
 
 PermissionBrokerClient* PermissionBrokerClient::Create() {
   return new PermissionBrokerClientImpl();
 }
 
 }  // namespace chromeos