Add Brand Code to UMA Uploads

chrome/browser/metrics/metrics_log_unittest.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 <string>
 
 #include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/port.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/tracked_objects.h"
+#include "chrome/browser/google/google_util.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/metrics/variations/variations_util.h"
 #include "chrome/common/metrics/proto/profiler_event.pb.h"
 #include "chrome/common/metrics/proto/system_profile.pb.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size.h"
 #include "webkit/plugins/webplugininfo.h"
 
 using base::TimeDelta;
 using metrics::ProfilerEventProto;
 using tracked_objects::ProcessDataSnapshot;
 using tracked_objects::TaskSnapshot;
 
 namespace {
 
 const char kClientId[] = "bogus client ID";
 const int kSessionId = 127;
 const int kScreenWidth = 1024;
 const int kScreenHeight = 768;
 const int kScreenCount = 3;
 const float kScreenScaleFactor = 2;
+const char* kBrandForTesting = "brand_for_testing";

[Ilya Sherman, 2013/01/24 00:31:46]

nit: This should have type "const char kBrandForTesting[]" or else "const char*
const kBrandForTesting"

[Mark P, 2013/01/24 00:43:05]

Done.

 const chrome_variations::ActiveGroupId kFieldTrialIds[] = {
   {37, 43},
   {13, 47},
   {23, 17}
 };
 
 class TestMetricsLog : public MetricsLog {
  public:
   TestMetricsLog(const std::string& client_id, int session_id)
       : MetricsLog(client_id, session_id) {
     chrome::RegisterLocalState(&prefs_);
+    brand_for_testing_.reset(
+        new google_util::BrandForTesting(kBrandForTesting));
 
 #if defined(OS_CHROMEOS)
     prefs_.SetInteger(prefs::kStabilityChildProcessCrashCount, 10);
     prefs_.SetInteger(prefs::kStabilityOtherUserCrashCount, 11);
     prefs_.SetInteger(prefs::kStabilityKernelCrashCount, 12);
     prefs_.SetInteger(prefs::kStabilitySystemUncleanShutdownCount, 13);
 #endif  // OS_CHROMEOS
   }
   virtual ~TestMetricsLog() {}
 
@@ skipping 31 matching lines @@
   virtual float GetScreenDeviceScaleFactor() const OVERRIDE {
     return kScreenScaleFactor;
   }
 
   virtual int GetScreenCount() const OVERRIDE {
     return kScreenCount;
   }
 
   TestingPrefServiceSimple prefs_;
 
+  scoped_ptr<google_util::BrandForTesting> brand_for_testing_;

[Ilya Sherman, 2013/01/23 23:32:54]

nit: No need to use a pointer; just allocate as a direct member var, and init in
the initializer list.

[Mark P, 2013/01/23 23:49:26]

I can do that if I make the kBrandForTesting a string; right now it's a global
char *.  (I need to change types because BrandForTesting's constructor is
explicit.)  If it's a string, I'm not supposed to have it in global scope. 
Hence, I can do your suggestion but then I'll have to move the definition of
kBrandForTesting.  I guess then it would have to be a public member variable
within this class (so the TEST_F functions can access it).  That seemed ickier
to me than using a scoped_ptr.

What do you think?

[Ilya Sherman, 2013/01/24 00:31:46]

I don't think the explicit on BrandForTesting's constructor should matter; but
if the code doesn't compile without it, you can always init as
brand_for_testing_(std::string(kBrandForTesting));

[Mark P, 2013/01/24 00:43:05]

Works now (without the explicit conversion).  Dunno why it didn't work before. 
*shrug*  I must've had something else wrong and misinterpret the error message.

+
   DISALLOW_COPY_AND_ASSIGN(TestMetricsLog);
 };
 
 }  // namespace
 
 class MetricsLogTest : public testing::Test {
  protected:
   void TestRecordEnvironment(bool proto_only) {
     TestMetricsLog log(kClientId, kSessionId);
 
     std::vector<webkit::WebPluginInfo> plugins;
     GoogleUpdateMetrics google_update_metrics;
     if (proto_only)
       log.RecordEnvironmentProto(plugins, google_update_metrics);
     else
       log.RecordEnvironment(plugins, google_update_metrics, NULL);
 
     const metrics::SystemProfileProto& system_profile = log.system_profile();
     ASSERT_EQ(arraysize(kFieldTrialIds),
               static_cast<size_t>(system_profile.field_trial_size()));
     for (size_t i = 0; i < arraysize(kFieldTrialIds); ++i) {
       const metrics::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());
     }
 
+    EXPECT_EQ(kBrandForTesting, system_profile.brand_code());
+
     const metrics::SystemProfileProto::Hardware& hardware =
         system_profile.hardware();
     EXPECT_EQ(kScreenWidth, hardware.primary_screen_width());
     EXPECT_EQ(kScreenHeight, hardware.primary_screen_height());
     EXPECT_EQ(kScreenScaleFactor, hardware.primary_screen_scale_factor());
     EXPECT_EQ(kScreenCount, hardware.screen_count());
 
     // TODO(isherman): Verify other data written into the protobuf as a result
     // of this call.
   }
@@ skipping 168 matching lines @@
   EXPECT_NE(std::string::npos,
             encoded.find(" childprocesscrashcount=\"10\""));
   EXPECT_EQ(std::string::npos,
             encoded.find(" otherusercrashcount="));
   EXPECT_EQ(std::string::npos,
             encoded.find(" kernelcrashcount="));
   EXPECT_EQ(std::string::npos,
             encoded.find(" systemuncleanshutdowns="));
 }
 #endif  // OS_CHROMEOS