Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/activity_log/activity_log.cc

 // Copyright (c) 2011 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 <set>
 #include <vector>
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 14 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/re2/re2/re2.h"
 
 namespace {
 
 // Concatenate arguments.
-std::string MakeArgList(const ListValue* args) {
+std::string MakeArgList(const base::ListValue* args) {
   std::string call_signature;
-  ListValue::const_iterator it = args->begin();
+  base::ListValue::const_iterator it = args->begin();
   for (; it != args->end(); ++it) {
     std::string arg;
     JSONStringValueSerializer serializer(&arg);
     if (serializer.SerializeAndOmitBinaryValues(**it)) {
       if (it != args->begin())
         call_signature += ", ";
       call_signature += arg;
     }
   }
   return call_signature;
@@ skipping 182 matching lines @@
 void ActivityLog::AddObserver(ActivityLog::Observer* observer) {
   observers_->AddObserver(observer);
 }
 
 void ActivityLog::RemoveObserver(ActivityLog::Observer* observer) {
   observers_->RemoveObserver(observer);
 }
 
 void ActivityLog::LogAPIActionInternal(const std::string& extension_id,
                                        const std::string& api_call,
-                                       ListValue* args,
+                                       base::ListValue* args,
                                        const std::string& extra,
                                        const APIAction::Type type) {
   std::string verb, manager;
   bool matches = RE2::FullMatch(api_call, "(.*?)\\.(.*)", &manager, &verb);
   if (matches) {
     if (!args->empty() && manager == "tabs") {
       APIAction::LookupTabId(api_call, args, profile_);
     }
 
     if (policy_) {
@@ skipping 25 matching lines @@
     observers_->Notify(&Observer::OnExtensionActivity, action);
     if (testing_mode_) LOG(INFO) << action->PrintForDebug();
   } else {
     LOG(ERROR) << "Unknown API call! " << api_call;
   }
 }
 
 // A wrapper around LogAPIActionInternal, but we know it's an API call.
 void ActivityLog::LogAPIAction(const std::string& extension_id,
                                const std::string& api_call,
-                               ListValue* args,
+                               base::ListValue* args,
                                const std::string& extra) {
   if (!IsLogEnabled() ||
       ActivityLogAPI::IsExtensionWhitelisted(extension_id)) return;
   LogAPIActionInternal(extension_id,
                        api_call,
                        args,
                        extra,
                        APIAction::CALL);
 }
 
 // A wrapper around LogAPIActionInternal, but we know it's actually an event
 // being fired and triggering extension code. Having the two separate methods
 // (LogAPIAction vs LogEventAction) lets us hide how we actually choose to
 // handle them. Right now they're being handled almost the same.
 void ActivityLog::LogEventAction(const std::string& extension_id,
                                  const std::string& api_call,
-                                 ListValue* args,
+                                 base::ListValue* args,
                                  const std::string& extra) {
   if (!IsLogEnabled() ||
       ActivityLogAPI::IsExtensionWhitelisted(extension_id)) return;
   LogAPIActionInternal(extension_id,
                        api_call,
                        args,
                        extra,
                        APIAction::EVENT_CALLBACK);
 }
 
 void ActivityLog::LogBlockedAction(const std::string& extension_id,
                                    const std::string& blocked_call,
-                                   ListValue* args,
+                                   base::ListValue* args,
                                    BlockedAction::Reason reason,
                                    const std::string& extra) {
   if (!IsLogEnabled() ||
       ActivityLogAPI::IsExtensionWhitelisted(extension_id)) return;
 
   if (policy_) {
     scoped_ptr<base::DictionaryValue> details(new DictionaryValue());
     std::string key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_REASON);
     details->SetInteger(key, static_cast<int>(reason));
     key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_EXTRA);
@@ skipping 14 matching lines @@
                                                           reason,
                                                           extra);
   observers_->Notify(&Observer::OnExtensionActivity, action);
   if (testing_mode_) LOG(INFO) << action->PrintForDebug();
 }
 
 void ActivityLog::LogDOMAction(const std::string& extension_id,
                                const GURL& url,
                                const string16& url_title,
                                const std::string& api_call,
-                               const ListValue* args,
+                               const base::ListValue* args,
                                DomActionType::Type call_type,
                                const std::string& extra) {
   if (!IsLogEnabled() ||
       ActivityLogAPI::IsExtensionWhitelisted(extension_id)) return;
   if (call_type == DomActionType::METHOD && api_call == "XMLHttpRequest.open")
     call_type = DomActionType::XHR;
 
   if (policy_) {
     scoped_ptr<base::DictionaryValue> details(new DictionaryValue());
     std::string key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_DOM_ACTION);
@@ skipping 111 matching lines @@
     // of content scripts will be empty.  We don't want to log it because
     // the call to tabs.executeScript will have already been logged anyway.
     if (!it->second.empty()) {
       std::string ext_scripts_str;
       for (std::set<std::string>::const_iterator it2 = it->second.begin();
            it2 != it->second.end();
            ++it2) {
         ext_scripts_str += *it2;
         ext_scripts_str += " ";
       }
-      scoped_ptr<ListValue> script_names(new ListValue());
-      script_names->Set(0, new StringValue(ext_scripts_str));
+      scoped_ptr<base::ListValue> script_names(new base::ListValue());
+      script_names->Set(0, new base::StringValue(ext_scripts_str));
       LogDOMAction(extension->id(),
                    on_url,
                    web_contents->GetTitle(),
                    std::string(),  // no api call here
                    script_names.get(),
                    DomActionType::INSERTED,
                    extra);
     }
   }
 }
 
 }  // namespace extensions