chrome://crashes: reload uploads.log every time the page refreshes

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 291 matching lines @@
     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,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&DebugDaemonClientImpl::OnStartSystemTracing,
+        base::Bind(&DebugDaemonClientImpl::OnStartMethod,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual bool RequestStopSystemTracing(const StopSystemTracingCallback&
       callback) OVERRIDE {
     if (pipe_reader_ != NULL) {
       LOG(ERROR) << "Busy doing StopSystemTracing";
       return false;
     }
 
@@ skipping 66 matching lines @@
 
     // Call the function.
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnTestICMP,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
+  virtual void UploadCrashes() OVERRIDE {
+    dbus::MethodCall method_call(debugd::kDebugdInterface,
+                                 debugd::kUploadCrashes);
+    debugdaemon_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&DebugDaemonClientImpl::OnStartMethod,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
  protected:
   virtual void Init(dbus::Bus* bus) OVERRIDE {
     debugdaemon_proxy_ =
         bus->GetObjectProxy(debugd::kDebugdServiceName,
                             dbus::ObjectPath(debugd::kDebugdServicePath));
   }
 
  private:
   // Called to check descriptor validity on a thread where i/o is permitted.
   static void CheckValidity(dbus::FileDescriptor* file_descriptor) {
@@ skipping 135 matching lines @@
       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) {
+  // Called when a response for a simple start is received.
+  void OnStartMethod(dbus::Response* response) {
     if (!response) {
-      LOG(ERROR) << "Failed to request systrace start";
+      LOG(ERROR) << "Failed to request start";
       return;
     }
   }
 
   // Called when a CheckValidity response is received.
   void OnCheckValidityRequestStopSystem(
       dbus::FileDescriptor* file_descriptor,
       const StopSystemTracingCallback& callback) {
     // Issue the dbus request to stop system tracing
     dbus::MethodCall method_call(
@@ skipping 113 matching lines @@
         FROM_HERE, base::Bind(callback, false, sample));
   }
   virtual void GetUserLogFiles(const GetLogsCallback& callback) OVERRIDE {
     std::map<std::string, std::string> user_logs;
     user_logs["preferences"] = "Preferences";
     user_logs["invalid_file"] = "Invalid File";
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, true, user_logs));
   }
-
   virtual void TestICMP(const std::string& ip_address,
                         const TestICMPCallback& callback) OVERRIDE {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, false, ""));
   }
-
   virtual void TestICMPWithOptions(
       const std::string& ip_address,
       const std::map<std::string, std::string>& options,
       const TestICMPCallback& callback) OVERRIDE {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, false, ""));
   }
+  virtual void UploadCrashes() OVERRIDE {}
 };
 
 DebugDaemonClient::DebugDaemonClient() {
 }
 
 DebugDaemonClient::~DebugDaemonClient() {
 }
 
 // static
 DebugDaemonClient::StopSystemTracingCallback
 DebugDaemonClient::EmptyStopSystemTracingCallback() {
   return base::Bind(&EmptyStopSystemTracingCallbackBody);
 }
 
 // static
 DebugDaemonClient* DebugDaemonClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new DebugDaemonClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new DebugDaemonClientStubImpl();
 }
 
 }  // namespace chromeos