Collect user logs that debugd can not access

chromeos/dbus/debug_daemon_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 <fcntl.h>
 #include <unistd.h>
 
 #include "chromeos/dbus/debug_daemon_client.h"
 
 #include "base/bind.h"
@@ skipping 228 matching lines @@
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetInterfaces);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetNetworkInterfaces,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  virtual void GetAllLogs(const GetAllLogsCallback& callback)
+  virtual void GetAllLogs(const GetLogsCallback& callback)
       OVERRIDE {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
-                                 "GetAllLogs");
+                                 debugd::kGetAllLogs);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetAllLogs,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
+  virtual void GetUserLogFiles(
+      const GetLogsCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(debugd::kDebugdInterface,
+                                 debugd::kGetUserLogFiles);
+    debugdaemon_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&DebugDaemonClientImpl::OnGetUserLogFiles,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   callback));
+  }
+
   virtual void StartSystemTracing() OVERRIDE {
     dbus::MethodCall method_call(
         debugd::kDebugdInterface,
         debugd::kSystraceStart);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString("all"); // TODO(sleffler) parameterize category list
 
     DVLOG(1) << "Requesting a systrace start";
     debugdaemon_proxy_->CallMethod(
         &method_call,
@@ skipping 117 matching lines @@
   void OnGetNetworkStatus(const GetNetworkStatusCallback& callback,
                           dbus::Response* response) {
     std::string status;
     if (response && dbus::MessageReader(response).PopString(&status))
       callback.Run(true, status);
     else
       callback.Run(false, "");
   }
 
   void OnGetModemStatus(const GetModemStatusCallback& callback,
-                          dbus::Response* response) {
+                        dbus::Response* response) {
     std::string status;
     if (response && dbus::MessageReader(response).PopString(&status))
       callback.Run(true, status);
     else
       callback.Run(false, "");
   }
 
   void OnGetNetworkInterfaces(const GetNetworkInterfacesCallback& callback,
                               dbus::Response* response) {
     std::string status;
     if (response && dbus::MessageReader(response).PopString(&status))
       callback.Run(true, status);
     else
       callback.Run(false, "");
   }
 
-  void OnGetAllLogs(const GetAllLogsCallback& callback,
+  void OnGetAllLogs(const GetLogsCallback& callback,
                     dbus::Response* response) {
     std::map<std::string, std::string> logs;
     bool broken = false; // did we see a broken (k,v) pair?
     dbus::MessageReader sub_reader(NULL);
     if (!response || !dbus::MessageReader(response).PopArray(&sub_reader)) {
       callback.Run(false, logs);
       return;
     }
     while (sub_reader.HasMoreData()) {
       dbus::MessageReader sub_sub_reader(NULL);
       std::string key, value;
       if (!sub_reader.PopDictEntry(&sub_sub_reader)
           || !sub_sub_reader.PopString(&key)
           || !sub_sub_reader.PopString(&value)) {
         broken = true;
         break;
       }
       logs[key] = value;
     }
     callback.Run(!sub_reader.HasMoreData() && !broken, logs);
   }
 
+  void OnGetUserLogFiles(const GetLogsCallback& callback,
+                         dbus::Response* response) {
+    return OnGetAllLogs(callback, response);
+  }
+
   // Called when a response for StartSystemTracing() is received.
   void OnStartSystemTracing(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to request systrace start";
       return;
     }
   }
 
   // Called when a CheckValidity response is received.
   void OnCheckValidityRequestStopSystem(
@@ skipping 81 matching lines @@
     callback.Run(false, "");
   }
   virtual void GetModemStatus(const GetModemStatusCallback& callback)
       OVERRIDE {
     callback.Run(false, "");
   }
   virtual void GetNetworkInterfaces(
       const GetNetworkInterfacesCallback& callback) OVERRIDE {
     callback.Run(false, "");
   }
-  virtual void GetAllLogs(const GetAllLogsCallback& callback) OVERRIDE {
+  virtual void GetAllLogs(const GetLogsCallback& callback) OVERRIDE {
     std::map<std::string, std::string> empty;
     callback.Run(false, empty);
   }
+  virtual void GetUserLogFiles(const GetLogsCallback& callback) OVERRIDE {
+    std::map<std::string, std::string> empty;
+    callback.Run(false, empty);
+  }
 
   virtual void TestICMP(const std::string& ip_address,
                         const TestICMPCallback& callback) OVERRIDE {
     callback.Run(false, "");
   }
 };
 
 DebugDaemonClient::DebugDaemonClient() {
 }
 
 DebugDaemonClient::~DebugDaemonClient() {
 }
 
 // static
 DebugDaemonClient::StopSystemTracingCallback
 DebugDaemonClient::EmptyStopSystemTracingCallback() {
   return base::Bind(&EmptyStopSystemTracingCallbackBody);
 }
 
 // static
 DebugDaemonClient* DebugDaemonClient::Create(DBusClientImplementationType type,
                                    dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new DebugDaemonClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new DebugDaemonClientStubImpl();
 }
 
 }  // namespace chromeos