Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/extensions/extension_ui_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/command_line.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 36 matching lines @@
                                                 management_policy_));
   }
 
   virtual void TearDown() OVERRIDE {
     handler_.reset();
     profile_.reset();
     // Execute any pending deletion tasks.
     message_loop_.RunUntilIdle();
   }
 
-  static DictionaryValue* DeserializeJSONTestData(const base::FilePath& path,
+  static base::DictionaryValue* DeserializeJSONTestData(
+      const base::FilePath& path,
       std::string *error) {
-    Value* value;
+    base::Value* value;
 
     JSONFileValueSerializer serializer(path);
     value = serializer.Deserialize(NULL, error);
 
-    return static_cast<DictionaryValue*>(value);
+    return static_cast<base::DictionaryValue*>(value);
   }
 
-  DictionaryValue* CreateExtensionDetailViewFromPath(
+  base::DictionaryValue* CreateExtensionDetailViewFromPath(
       const base::FilePath& extension_path,
       const std::vector<ExtensionPage>& pages,
       Manifest::Location location) {
     std::string error;
 
     base::FilePath manifest_path = extension_path.Append(kManifestFilename);
-    scoped_ptr<DictionaryValue> extension_data(DeserializeJSONTestData(
+    scoped_ptr<base::DictionaryValue> extension_data(DeserializeJSONTestData(
         manifest_path, &error));
     EXPECT_EQ("", error);
 
     scoped_refptr<Extension> extension(Extension::Create(
         extension_path, location, *extension_data, Extension::REQUIRE_KEY,
         &error));
     EXPECT_TRUE(extension.get());
     EXPECT_EQ("", error);
 
     return handler_->CreateExtensionDetailValue(extension.get(), pages, NULL);
   }
 
   void CompareExpectedAndActualOutput(
       const base::FilePath& extension_path,
       const std::vector<ExtensionPage>& pages,
       const base::FilePath& expected_output_path) {
     std::string error;
 
-    scoped_ptr<DictionaryValue> expected_output_data(DeserializeJSONTestData(
-        expected_output_path, &error));
+    scoped_ptr<base::DictionaryValue> expected_output_data(
+        DeserializeJSONTestData(expected_output_path, &error));
     EXPECT_EQ("", error);
 
     // Produce test output.
-    scoped_ptr<DictionaryValue> actual_output_data(
+    scoped_ptr<base::DictionaryValue> actual_output_data(
         CreateExtensionDetailViewFromPath(
             extension_path, pages, Manifest::INVALID_LOCATION));
 
     // Compare the outputs.
     // Ignore unknown fields in the actual output data.
     std::string paths_details = " - expected (" +
         expected_output_path.MaybeAsASCII() + ") vs. actual (" +
         extension_path.MaybeAsASCII() + ")";
-    for (DictionaryValue::Iterator field(*expected_output_data);
+    for (base::DictionaryValue::Iterator field(*expected_output_data);
          !field.IsAtEnd(); field.Advance()) {
-      const Value* expected_value = &field.value();
-      Value* actual_value = NULL;
+      const base::Value* expected_value = &field.value();
+      base::Value* actual_value = NULL;
       EXPECT_TRUE(actual_output_data->Get(field.key(), &actual_value)) <<
           field.key() + " is missing" + paths_details;
       EXPECT_TRUE(expected_value->Equals(actual_value)) << field.key() +
           paths_details;
     }
   }
 
   base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
@@ skipping 78 matching lines @@
   EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_test_dir_path));
 
   extension_path = data_test_dir_path.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
 
   std::vector<ExtensionPage> pages;
 
-  scoped_ptr<DictionaryValue> extension_details(
+  scoped_ptr<base::DictionaryValue> extension_details(
       CreateExtensionDetailViewFromPath(
           extension_path, pages, Manifest::UNPACKED));
 
   bool ui_allow_reload = false;
   bool ui_is_unpacked = false;
   base::FilePath::StringType ui_path;
 
   EXPECT_TRUE(extension_details->GetBoolean("allow_reload", &ui_allow_reload));
   EXPECT_TRUE(extension_details->GetBoolean("isUnpacked", &ui_is_unpacked));
   EXPECT_TRUE(extension_details->GetString("path", &ui_path));
@@ skipping 11 matching lines @@
   EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_test_dir_path));
 
   extension_path = data_test_dir_path.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
 
   std::vector<ExtensionPage> pages;
 
-  scoped_ptr<DictionaryValue> extension_details(
+  scoped_ptr<base::DictionaryValue> extension_details(
       CreateExtensionDetailViewFromPath(
           extension_path, pages, Manifest::EXTERNAL_PREF));
 
   bool ui_allow_reload = true;
   bool ui_is_unpacked = true;
   base::FilePath::StringType ui_path;
 
   EXPECT_TRUE(extension_details->GetBoolean("allow_reload", &ui_allow_reload));
   EXPECT_TRUE(extension_details->GetBoolean("isUnpacked", &ui_is_unpacked));
   EXPECT_FALSE(extension_details->GetString("path", &ui_path));
   EXPECT_FALSE(ui_allow_reload);
   EXPECT_FALSE(ui_is_unpacked);
 }
 
 // Test that the extension path is correctly propagated into the extension
 // details.
 TEST_F(ExtensionUITest, PathPropagation) {
   base::FilePath data_test_dir_path, extension_path;
   EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_test_dir_path));
 
   extension_path = data_test_dir_path.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
 
   std::vector<ExtensionPage> pages;
 
-  scoped_ptr<DictionaryValue> extension_details(
+  scoped_ptr<base::DictionaryValue> extension_details(
       CreateExtensionDetailViewFromPath(
           extension_path, pages, Manifest::UNPACKED));
 
   base::FilePath::StringType ui_path;
 
   EXPECT_TRUE(extension_details->GetString("path", &ui_path));
   EXPECT_EQ(extension_path, base::FilePath(ui_path));
 }
 
 }  // namespace extensions