Make DBusStatistics only run on the main thread

dbus/dbus_statistics.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 "dbus/dbus_statistics.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
+#include "base/threading/platform_thread.h"
 #include "base/time.h"
 
 namespace dbus {
 
 namespace {
 
 // Used to store dbus statistics sorted alphabetically by service, interface,
 // then method (using std::string <).
 struct Stat {
   Stat(const std::string& service,
@@ skipping 30 matching lines @@
 };
 
 typedef std::set<Stat*, Stat::PtrCompare> StatSet;
 
 //------------------------------------------------------------------------------
 // DBusStatistics
 
 // Simple class for gathering DBus usage statistics.
 class DBusStatistics {
  public:
-  DBusStatistics() : start_time_(base::Time::Now()) {
+  DBusStatistics()
+      : start_time_(base::Time::Now()),
+        origin_thread_id_(base::PlatformThread::CurrentId()) {
   }
 
   ~DBusStatistics() {
+    DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
     STLDeleteContainerPointers(stats_.begin(), stats_.end());
   }
 
   // Enum to specify which field in Stat to increment in AddStat
   enum StatType {
     TYPE_SENT_METHOD_CALLS,
     TYPE_RECEIVED_SIGNALS,
     TYPE_SENT_BLOCKING_METHOD_CALLS
   };
 
   // Add a call to |method| for |interface|. See also MethodCall in message.h.
   void AddStat(const std::string& service,
                const std::string& interface,
                const std::string& method,
                StatType type) {
+    if (base::PlatformThread::CurrentId() != origin_thread_id_) {
+      DLOG(WARNING) << "Ignoring DBusStatistics::AddStat call from thread: "
+                    << base::PlatformThread::CurrentId();
+      return;
+    }
     Stat* stat = GetStat(service, interface, method, true);
     DCHECK(stat);
     if (type == TYPE_SENT_METHOD_CALLS)
       ++stat->sent_method_calls;
     else if (type == TYPE_RECEIVED_SIGNALS)
       ++stat->received_signals;
     else if (type == TYPE_SENT_BLOCKING_METHOD_CALLS)
       ++stat->sent_blocking_method_calls;
     else
       NOTREACHED();
   }
 
   // Look up the Stat entry in |stats_|. If |add_stat| is true, add a new entry
   // if one does not already exist.
   Stat* GetStat(const std::string& service,
                 const std::string& interface,
                 const std::string& method,
                 bool add_stat) {
+    DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
     scoped_ptr<Stat> stat(new Stat(service, interface, method));
     StatSet::iterator found = stats_.find(stat.get());
     if (found != stats_.end())
       return *found;
     if (!add_stat)
       return NULL;
     found = stats_.insert(stat.release()).first;
     return *found;
   }
 
   StatSet& stats() { return stats_; }
   base::Time start_time() { return start_time_; }
 
  private:
   StatSet stats_;
   base::Time start_time_;
+  base::PlatformThreadId origin_thread_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusStatistics);
 };
 
 DBusStatistics* g_dbus_statistics = NULL;
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 
@@ skipping 136 matching lines @@
   *sent = stat->sent_method_calls;
   *received = stat->received_signals;
   *blocking = stat->sent_blocking_method_calls;
   return true;
 }
 
 }  // namespace testing
 
 }  // namespace statistics
 }  // namespace dbus