Add some histograms to the D-Bus library:

dbus/object_proxy.h

 // Copyright (c) 2011 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.
 
 #ifndef DBUS_OBJECT_PROXY_H_
 #define DBUS_OBJECT_PROXY_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 #include <dbus/dbus.h>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
+#include "base/time.h"
 
 class MessageLoop;
 
 namespace dbus {
 
 class Bus;
 class MethodCall;
 class Response;
 class Signal;
 
@@ skipping 83 matching lines @@
   // This is protected, so we can define sub classes.
   virtual ~ObjectProxy();
 
  private:
   friend class base::RefCountedThreadSafe<ObjectProxy>;
 
   // Struct of data we'll be passing from StartAsyncMethodCall() to
   // OnPendingCallIsCompleteThunk().
   struct OnPendingCallIsCompleteData {
     OnPendingCallIsCompleteData(ObjectProxy* in_object_proxy,
-                                ResponseCallback in_response_callback);
+                                ResponseCallback in_response_callback,
+                                base::TimeTicks start_time);
     ~OnPendingCallIsCompleteData();
 
     ObjectProxy* object_proxy;
     ResponseCallback response_callback;
+    base::TimeTicks start_time;
   };
 
   // Starts the async method call. This is a helper function to implement
   // CallMethod().
   void StartAsyncMethodCall(int timeout_ms,
                             void* request_message,
-                            ResponseCallback response_callback);
+                            ResponseCallback response_callback,
+                            base::TimeTicks start_time);
 
   // Called when the pending call is complete.
   void OnPendingCallIsComplete(DBusPendingCall* pending_call,
-                               ResponseCallback response_callback);
+                               ResponseCallback response_callback,
+                               base::TimeTicks start_time);
 
   // Runs the response callback with the given response object.
   void RunResponseCallback(ResponseCallback response_callback,
+                           base::TimeTicks start_time,
                            void* response_message);
 
   // Redirects the function call to OnPendingCallIsComplete().
   static void OnPendingCallIsCompleteThunk(DBusPendingCall* pending_call,
                                            void* user_data);
 
   // Helper function for ConnectToSignal().
   void ConnectToSignalInternal(
       const std::string& interface_name,
       const std::string& signal_name,
       SignalCallback signal_callback,
       OnConnectedCallback on_connected_callback);
 
   // Called when the object proxy is connected to the signal, or failed.
   void OnConnected(OnConnectedCallback on_connected_callback,
                    const std::string& interface_name,
                    const std::string& signal_name,
                    bool success);
 
   // Handles the incoming request messages and dispatches to the signal
   // callbacks.
   DBusHandlerResult HandleMessage(DBusConnection* connection,
                                   DBusMessage* raw_message);
 
   // Runs the method. Helper function for HandleMessage().
-  void RunMethod(SignalCallback signal_callback, Signal* signal);
+  void RunMethod(base::TimeTicks start_time,
+                 SignalCallback signal_callback,
+                 Signal* signal);
 
   // Redirects the function call to HandleMessage().
   static DBusHandlerResult HandleMessageThunk(DBusConnection* connection,
                                               DBusMessage* raw_message,
                                               void* user_data);
 
   Bus* bus_;
   std::string service_name_;
   std::string object_path_;
 
   // True if the message filter was added.
   bool filter_added_;
 
   // The method table where keys are absolute signal names (i.e. interface
   // name + signal name), and values are the corresponding callbacks.
   typedef std::map<std::string, SignalCallback> MethodTable;
   MethodTable method_table_;
 
   std::vector<std::string> match_rules_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectProxy);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_OBJECT_PROXY_H_