Update dbus_statistics to use C++11 more effectively, remove obsolete stl_util use.

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 <map>
 #include <memory>
-#include <set>
+#include <tuple>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/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,
        const std::string& interface,
        const std::string& method)
       : service(service),
         interface(interface),
         method(method),
         sent_method_calls(0),
         received_signals(0),
         sent_blocking_method_calls(0) {
   }
   std::string service;
   std::string interface;
   std::string method;
   int sent_method_calls;
   int received_signals;
   int sent_blocking_method_calls;
 
-  bool Compare(const Stat& other) const {
-    if (service != other.service)
-      return service < other.service;
-    if (interface != other.interface)
-      return interface < other.interface;
-    return method < other.method;
-  }
-
   struct PtrCompare {
     bool operator()(Stat* lhs, Stat* rhs) const {
       DCHECK(lhs && rhs);
-      return lhs->Compare(*rhs);
+      return std::tie(lhs->service, lhs->interface, lhs->method) <
+             std::tie(rhs->service, rhs->interface, rhs->method);
     }
   };
 };
 
-typedef std::set<Stat*, Stat::PtrCompare> StatSet;
+using StatSet = std::map<Stat*, std::unique_ptr<Stat>, Stat::PtrCompare>;

[satorux1, 2016/10/11 01:29:58]

why was it changed from set to map?

if it's a map something like below may be easier to understand:

map<tuple<string, string, string>, Stat> 

where 'Stat' does no have include service, interface, method.

[Avi (use Gerrit), 2016/10/11 16:31:46]

In doing the conversions I've been switching because you lose the ability to do
a find() on a set<unique_ptr> as well as the ability to remove items.

Switching to a map that way makes sense.

 
 //------------------------------------------------------------------------------
 // DBusStatistics
 
 // Simple class for gathering DBus usage statistics.
 class DBusStatistics {
  public:
   DBusStatistics()
       : start_time_(base::Time::Now()),
         origin_thread_id_(base::PlatformThread::CurrentId()) {
   }
 
   ~DBusStatistics() {
     DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
-    base::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.
@@ skipping 18 matching lines @@
       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());
-    std::unique_ptr<Stat> stat(new Stat(service, interface, method));
-    StatSet::iterator found = stats_.find(stat.get());
+    std::unique_ptr<Stat> stat =
+        base::MakeUnique<Stat>(service, interface, method);
+    auto found = stats_.find(stat.get());
     if (found != stats_.end())
-      return *found;
+      return found->first;
     if (!add_stat)
-      return NULL;
-    found = stats_.insert(stat.release()).first;
-    return *found;
+      return nullptr;
+    Stat* stat_ptr = stat.get();
+    stats_[stat_ptr] = std::move(stat);
+    return stat_ptr;
   }
 
   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;
+DBusStatistics* g_dbus_statistics = nullptr;
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 
 namespace statistics {
 
 void Initialize() {
   if (g_dbus_statistics)
     delete g_dbus_statistics;  // reset statistics
   g_dbus_statistics = new DBusStatistics();
 }
 
 void Shutdown() {
   delete g_dbus_statistics;
-  g_dbus_statistics = NULL;
+  g_dbus_statistics = nullptr;
 }
 
 void AddSentMethodCall(const std::string& service,
                        const std::string& interface,
                        const std::string& method) {
   if (!g_dbus_statistics)
     return;
   g_dbus_statistics->AddStat(
       service, interface, method, DBusStatistics::TYPE_SENT_METHOD_CALLS);
 }
@@ skipping 27 matching lines @@
   if (stats.empty())
     return "No DBus calls.";
 
   base::TimeDelta dtime = base::Time::Now() - g_dbus_statistics->start_time();
   int dminutes = dtime.InMinutes();
   dminutes = std::max(dminutes, 1);
 
   std::string result;
   int sent = 0, received = 0, sent_blocking = 0;
   // Stats are stored in order by service, then interface, then method.
-  for (StatSet::const_iterator iter = stats.begin(); iter != stats.end(); ) {
-    StatSet::const_iterator cur_iter = iter;
-    StatSet::const_iterator next_iter = ++iter;
-    const Stat* stat = *cur_iter;
+  for (auto iter = stats.begin(); iter != stats.end();) {
+    auto cur_iter = iter;
+    auto next_iter = ++iter;
+    const Stat* stat = cur_iter->first;
     sent += stat->sent_method_calls;
     received += stat->received_signals;
     sent_blocking += stat->sent_blocking_method_calls;
     // If this is not the last stat, and if the next stat matches the current
     // stat, continue.
     if (next_iter != stats.end() &&
-        (*next_iter)->service == stat->service &&
-        (show < SHOW_INTERFACE || (*next_iter)->interface == stat->interface) &&
-        (show < SHOW_METHOD || (*next_iter)->method == stat->method))
+        next_iter->first->service == stat->service &&
+        (show < SHOW_INTERFACE ||
+         next_iter->first->interface == stat->interface) &&
+        (show < SHOW_METHOD || next_iter->first->method == stat->method))
       continue;
 
     if (!sent && !received && !sent_blocking)
         continue;  // No stats collected for this line, skip it and continue.
 
     // Add a line to the result and clear the counts.
     std::string line;
     if (show == SHOW_SERVICE) {
       line += stat->service;
     } else {
@@ skipping 56 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