metrics: Update tests to send user in session state change.

metrics_daemon_test.cc

 // Copyright (c) 2010 The Chromium OS 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 <utime.h>
 
+#include <string>
+#include <vector>
+
 #include <base/file_util.h>
 #include <gtest/gtest.h>
 
 #include "counter_mock.h"
 #include "metrics_daemon.h"
 #include "metrics_library_mock.h"
 
 using base::Time;
 using base::TimeTicks;
 using chromeos_metrics::FrequencyCounter;
 using chromeos_metrics::FrequencyCounterMock;
 using chromeos_metrics::TaggedCounterMock;
 using chromeos_metrics::TaggedCounterReporter;
 using chromeos_metrics::TaggedCounterReporterMock;
+using std::string;
+using std::vector;
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 static const int kSecondsPerDay = 24 * 60 * 60;
 
 static const char kTestDir[] = "test";
 static const char kLastFile[] = "test/last";
 static const char kCurrentFile[] = "test/current";
 
@@ skipping 127 matching lines @@
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*user_crash_interval_, Update(_, _))
         .Times(1)
         .RetiresOnSaturation();
     ExpectFrequencyFlushCalls();
   }
 
   // Adds a metrics library mock expectation that the specified metric
   // will be generated.
-  void ExpectMetric(const std::string& name, int sample,
+  void ExpectMetric(const string& name, int sample,
                     int min, int max, int buckets) {
     EXPECT_CALL(metrics_lib_, SendToUMA(name, sample, min, max, buckets))
         .Times(1)
         .WillOnce(Return(true))
         .RetiresOnSaturation();
   }
 
   // Adds a metrics library mock expectation that the specified daily
   // use time metric will be generated.
   void ExpectDailyUseTimeMetric(int sample) {
     ExpectMetric(MetricsDaemon::kMetricDailyUseTimeName, sample,
                  MetricsDaemon::kMetricDailyUseTimeMin,
                  MetricsDaemon::kMetricDailyUseTimeMax,
                  MetricsDaemon::kMetricDailyUseTimeBuckets);
   }
 
   // Converts from seconds to a Time object.
   Time TestTime(int64 seconds) {
     return Time::FromInternalValue(seconds * Time::kMicrosecondsPerSecond);
   }
 
-  // Creates a new DBus signal message with a single string
-  // argument. The message can be deallocated through
-  // DeleteDBusMessage.
+  // Creates a new DBus signal message with zero or more string arguments.
+  // The message can be deallocated through DeleteDBusMessage.
   //
   // |path| is the object emitting the signal.
   // |interface| is the interface the signal is emitted from.
   // |name| is the name of the signal.
-  // |arg_value| is the value of the string argument.
-  DBusMessage* NewDBusSignalString(const std::string& path,
-                                   const std::string& interface,
-                                   const std::string& name,
-                                   const std::string& arg_value) {
+  // |arg_values| contains the values of the string arguments.
+  DBusMessage* NewDBusSignalString(const string& path,
+                                   const string& interface,
+                                   const string& name,
+                                   const vector<string>& arg_values) {
     DBusMessage* msg = dbus_message_new_signal(path.c_str(),
                                                interface.c_str(),
                                                name.c_str());
     DBusMessageIter iter;
     dbus_message_iter_init_append(msg, &iter);
-    const char* arg_value_c = arg_value.c_str();
-    dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &arg_value_c);
+    for (vector<string>::const_iterator it = arg_values.begin();
+         it != arg_values.end(); ++it) {
+      const char* str_value = it->c_str();
+      dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &str_value);
+    }
     return msg;
   }
 
   // Deallocates the DBus message |msg| previously allocated through
   // dbus_message_new*.
   void DeleteDBusMessage(DBusMessage* msg) {
     dbus_message_unref(msg);
   }
 
   // Get the frequency counter for the given name.
@@ skipping 82 matching lines @@
       Update(1))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricUserCrashesWeeklyName),
       Update(1))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*user_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
+  vector<string> signal_args;
   msg = NewDBusSignalString("/",
                             "org.chromium.CrashReporter",
                             "UserCrash",
-                            "");
+                            signal_args);
   res = MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
+  signal_args.clear();
+  signal_args.push_back("on");
   msg = NewDBusSignalString("/",
                             "org.chromium.PowerManager",
                             "PowerStateChanged",
-                            "on");
+                            signal_args);
   EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
   res = MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(MetricsDaemon::kPowerStateOn, daemon_.power_state_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
+  signal_args.clear();
   IgnoreActiveUseUpdate();
   msg = NewDBusSignalString("/",
                             "org.chromium.PowerManager",
                             "ScreenIsUnlocked",
-                            "");
+                            signal_args);
   EXPECT_FALSE(daemon_.user_active_);
   res = MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
   IgnoreActiveUseUpdate();
+  signal_args.clear();
+  signal_args.push_back("started");
+  signal_args.push_back("bob");  // arbitrary username
   msg = NewDBusSignalString("/org/chromium/SessionManager",
                             "org.chromium.SessionManagerInterface",
                             "SessionStateChanged",
-                            "started");
+                            signal_args);
   EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_);
   res = MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(MetricsDaemon::kSessionStateStarted, daemon_.session_state_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
+  signal_args.clear();
+  signal_args.push_back("randomstate");
+  signal_args.push_back("bob");  // arbitrary username
   msg = NewDBusSignalString("/",
                             "org.chromium.UnknownService.Manager",
                             "StateChanged",
-                            "randomstate");
+                            signal_args);
   res = MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_NOT_YET_HANDLED, res);
   DeleteDBusMessage(msg);
 }
 
 TEST_F(MetricsDaemonTest, PowerStateChanged) {
   ExpectActiveUseUpdate(7, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(7 * kSecondsPerDay + 15));
   EXPECT_TRUE(daemon_.user_active_);
@@ skipping 148 matching lines @@
 TEST_F(MetricsDaemonTest, GetHistogramPath) {
   EXPECT_EQ("/var/log/metrics/Logging.AnyCrashesDaily",
             daemon_.GetHistogramPath(
                 MetricsDaemon::kMetricAnyCrashesDailyName).value());
 }
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }