Cleanup unecessary namespaces in variations_service_unittest.cc.

chrome/browser/metrics/variations_service_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 "base/base64.h"
 #include "base/string_split.h"
 #include "chrome/browser/metrics/proto/study.pb.h"
 #include "chrome/browser/metrics/variations_service.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome_variations {
 
 namespace {
 
 // Converts |time| to Study proto format.
 int64 TimeToProtoTime(const base::Time& time) {
   return (time - base::Time::UnixEpoch()).InSeconds();
 }
 
 // Populates |seed| with simple test data. The resulting seed will contain one
 // study called "test", which contains one experiment called "abc" with
 // probability weight 100. |seed|'s study field will be cleared before adding
 // the new study.
-chrome_variations::TrialsSeed CreateTestSeed() {
-  chrome_variations::TrialsSeed seed;
-  chrome_variations::Study* study = seed.add_study();
+TrialsSeed CreateTestSeed() {
+  TrialsSeed seed;
+  Study* study = seed.add_study();
   study->set_name("test");
   study->set_default_experiment_name("abc");
-  chrome_variations::Study_Experiment* experiment = study->add_experiment();
+  Study_Experiment* experiment = study->add_experiment();
   experiment->set_name("abc");
   experiment->set_probability_weight(100);
   return seed;
 }
 
 }  // namespace
 
 TEST(VariationsServiceTest, CheckStudyChannel) {
   const chrome::VersionInfo::Channel channels[] = {
     chrome::VersionInfo::CHANNEL_CANARY,
@@ skipping 72 matching lines @@
     EXPECT_EQ(test_cases[i].en_us_result,
               VariationsService::CheckStudyLocale(filter, "en-US"));
     EXPECT_EQ(test_cases[i].en_ca_result,
               VariationsService::CheckStudyLocale(filter, "en-CA"));
     EXPECT_EQ(test_cases[i].fr_result,
               VariationsService::CheckStudyLocale(filter, "fr"));
   }
 }
 
 TEST(VariationsServiceTest, CheckStudyPlatform) {
-  const chrome_variations::Study_Platform platforms[] = {
-    chrome_variations::Study_Platform_PLATFORM_WINDOWS,
-    chrome_variations::Study_Platform_PLATFORM_MAC,
-    chrome_variations::Study_Platform_PLATFORM_LINUX,
-    chrome_variations::Study_Platform_PLATFORM_CHROMEOS,
-    chrome_variations::Study_Platform_PLATFORM_ANDROID,
-    chrome_variations::Study_Platform_PLATFORM_IOS,
+  const Study_Platform platforms[] = {
+    Study_Platform_PLATFORM_WINDOWS,
+    Study_Platform_PLATFORM_MAC,
+    Study_Platform_PLATFORM_LINUX,
+    Study_Platform_PLATFORM_CHROMEOS,
+    Study_Platform_PLATFORM_ANDROID,
+    Study_Platform_PLATFORM_IOS,
   };
   ASSERT_EQ(Study_Platform_Platform_ARRAYSIZE,
             static_cast<int>(arraysize(platforms)));
   bool platform_added[arraysize(platforms)] = { 0 };
 
   Study_Filter filter;
 
   // Check in the forwarded order. The loop cond is <= arraysize(platforms)
   // instead of < so that the result of adding the last channel gets checked.
   for (size_t i = 0; i <= arraysize(platforms); ++i) {
@@ skipping 165 matching lines @@
         << "Case " << i << " failed!";
   }
 }
 
 TEST(VariationsServiceTest, LoadSeed) {
   TestingPrefService pref_service;
 
   VariationsService::RegisterPrefs(&pref_service);
 
   // Store good seed data to test if loading from prefs works.
-  chrome_variations::TrialsSeed seed = CreateTestSeed();
+  TrialsSeed seed = CreateTestSeed();
 
   std::string serialized_seed;
   seed.SerializeToString(&serialized_seed);
   std::string base64_serialized_seed;
   ASSERT_TRUE(base::Base64Encode(serialized_seed, &base64_serialized_seed));
   pref_service.SetString(prefs::kVariationsSeed, base64_serialized_seed);
 
   VariationsService variations_service;
-  chrome_variations::TrialsSeed loaded_seed;
+  TrialsSeed loaded_seed;
   EXPECT_TRUE(
       variations_service.LoadTrialsSeedFromPref(&pref_service, &loaded_seed));
 
   std::string serialized_loaded_seed;
   loaded_seed.SerializeToString(&serialized_loaded_seed);
   // Check that the loaded data is the same as the original.
   EXPECT_EQ(serialized_seed, serialized_loaded_seed);
   // Make sure the pref hasn't been changed.
   EXPECT_FALSE(
       pref_service.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
@@ skipping 10 matching lines @@
   EXPECT_TRUE(
       pref_service.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 }
 
 TEST(VariationsServiceTest, StoreSeed) {
   TestingPrefService pref_service;
 
   VariationsService::RegisterPrefs(&pref_service);
   const base::Time now = base::Time::Now();
 
-  chrome_variations::TrialsSeed seed = CreateTestSeed();
+  TrialsSeed seed = CreateTestSeed();
 
   VariationsService variations_service;
   std::string serialized_seed;
   seed.SerializeToString(&serialized_seed);
   EXPECT_TRUE(
       variations_service.StoreSeedData(serialized_seed, now, &pref_service));
   // Make sure the pref was actually set.
   EXPECT_FALSE(
       pref_service.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 
@@ skipping 81 matching lines @@
   ASSERT_TRUE(valid);
   Study_Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   valid = VariationsService::ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   EXPECT_FALSE(valid);
 }
 
 }  // namespace chrome_variations