Change UMA proto product field to be an int32.

components/metrics/metrics_log_unittest.cc

 // Copyright 2014 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 "components/metrics/metrics_log.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 28 matching lines @@
 const variations::ActiveGroupId kSyntheticTrials[] = {
   {55, 15},
   {66, 16}
 };
 
 class TestMetricsLog : public MetricsLog {
  public:
   TestMetricsLog(const std::string& client_id,
                  int session_id,
                  LogType log_type,
-                 metrics::MetricsServiceClient* client,
+                 MetricsServiceClient* client,
                  TestingPrefServiceSimple* prefs)
       : MetricsLog(client_id, session_id, log_type, client, prefs),
         prefs_(prefs) {
     InitPrefs();
- }
+  }
 
   virtual ~TestMetricsLog() {}
 
-  const metrics::ChromeUserMetricsExtension& uma_proto() const {
+  const ChromeUserMetricsExtension& uma_proto() const {
     return *MetricsLog::uma_proto();
   }
 
-  const metrics::SystemProfileProto& system_profile() const {
+  const SystemProfileProto& system_profile() const {
     return uma_proto().system_profile();
   }
 
  private:
   void InitPrefs() {
-    prefs_->SetString(metrics::prefs::kMetricsReportingEnabledTimestamp,
+    prefs_->SetString(prefs::kMetricsReportingEnabledTimestamp,
                       base::Int64ToString(kEnabledDate));
   }
 
   virtual void GetFieldTrialIds(
       std::vector<variations::ActiveGroupId>* field_trial_ids) const
       OVERRIDE {
     ASSERT_TRUE(field_trial_ids->empty());
 
     for (size_t i = 0; i < arraysize(kFieldTrialIds); ++i) {
       field_trial_ids->push_back(kFieldTrialIds[i]);
     }
   }
 
   // Weak pointer to the PrefsService used by this log.
   TestingPrefServiceSimple* prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMetricsLog);
 };
 
 }  // namespace
 
 class MetricsLogTest : public testing::Test {
  public:
   MetricsLogTest() {
     MetricsLog::RegisterPrefs(prefs_.registry());
-    metrics::MetricsStateManager::RegisterPrefs(prefs_.registry());
+    MetricsStateManager::RegisterPrefs(prefs_.registry());
   }
 
   virtual ~MetricsLogTest() {
   }
 
  protected:
   // Check that the values in |system_values| correspond to the test data
   // defined at the top of this file.
-  void CheckSystemProfile(const metrics::SystemProfileProto& system_profile) {
+  void CheckSystemProfile(const SystemProfileProto& system_profile) {
     EXPECT_EQ(kInstallDateExpected, system_profile.install_date());
     EXPECT_EQ(kEnabledDateExpected, system_profile.uma_enabled_date());
 
     ASSERT_EQ(arraysize(kFieldTrialIds) + arraysize(kSyntheticTrials),
               static_cast<size_t>(system_profile.field_trial_size()));
     for (size_t i = 0; i < arraysize(kFieldTrialIds); ++i) {
-      const metrics::SystemProfileProto::FieldTrial& field_trial =
+      const SystemProfileProto::FieldTrial& field_trial =
           system_profile.field_trial(i);
       EXPECT_EQ(kFieldTrialIds[i].name, field_trial.name_id());
       EXPECT_EQ(kFieldTrialIds[i].group, field_trial.group_id());
     }
     // Verify the right data is present for the synthetic trials.
     for (size_t i = 0; i < arraysize(kSyntheticTrials); ++i) {
-      const metrics::SystemProfileProto::FieldTrial& field_trial =
+      const SystemProfileProto::FieldTrial& field_trial =
           system_profile.field_trial(i + arraysize(kFieldTrialIds));
       EXPECT_EQ(kSyntheticTrials[i].name, field_trial.name_id());
       EXPECT_EQ(kSyntheticTrials[i].group, field_trial.group_id());
     }
 
-    EXPECT_EQ(metrics::TestMetricsServiceClient::kBrandForTesting,
+    EXPECT_EQ(TestMetricsServiceClient::kBrandForTesting,
               system_profile.brand_code());
 
-    const metrics::SystemProfileProto::Hardware& hardware =
+    const SystemProfileProto::Hardware& hardware =
         system_profile.hardware();
 
     EXPECT_TRUE(hardware.has_cpu());
     EXPECT_TRUE(hardware.cpu().has_vendor_name());
     EXPECT_TRUE(hardware.cpu().has_signature());
 
     // TODO(isherman): Verify other data written into the protobuf as a result
     // of this call.
   }
 
@@ skipping 234 matching lines @@
   EXPECT_FALSE(stability.has_incomplete_shutdown_count());
   EXPECT_FALSE(stability.has_breakpad_registration_success_count());
   EXPECT_FALSE(stability.has_breakpad_registration_failure_count());
   EXPECT_FALSE(stability.has_debugger_present_count());
   EXPECT_FALSE(stability.has_debugger_not_present_count());
 }
 
 TEST_F(MetricsLogTest, ChromeChannelWrittenToProtobuf) {
   TestMetricsServiceClient client;
   TestMetricsLog log(
-      "user@test.com", kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
+      kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
   EXPECT_TRUE(log.uma_proto().system_profile().has_channel());
 }
 
+TEST_F(MetricsLogTest, ProductNotSetIfDefault) {
+  TestMetricsServiceClient client;
+  EXPECT_EQ(ChromeUserMetricsExtension::CHROME, client.GetProduct());
+  TestMetricsLog log(
+      kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
+  // Check that the product isn't set, since it's default and also verify the
+  // default value is indeed equal to Chrome.
+  EXPECT_FALSE(log.uma_proto().has_product());
+  EXPECT_EQ(ChromeUserMetricsExtension::CHROME, log.uma_proto().product());
+}
+
+TEST_F(MetricsLogTest, ProductSetIfNotDefault) {
+  const int32_t kTestProduct = 100;
+  EXPECT_NE(ChromeUserMetricsExtension::CHROME, kTestProduct);
+
+  TestMetricsServiceClient client;
+  client.set_product(kTestProduct);
+  TestMetricsLog log(
+      kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
+  // Check that the product is set to |kTestProduct|.
+  EXPECT_TRUE(log.uma_proto().has_product());
+  EXPECT_EQ(kTestProduct, log.uma_proto().product());
+}
+
 }  // namespace metrics