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

chrome/browser/devtools/devtools_targets_ui.cc

 // Copyright 2013 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 "chrome/browser/devtools/devtools_targets_ui.h"
 
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 116 matching lines @@
     const content::NotificationDetails& details) {
   const int kUpdateDelay = 100;
   timer_.reset(
       new CancelableTimer(
           base::Bind(&RenderViewHostTargetsUIHandler::UpdateTargets,
                      base::Unretained(this)),
           base::TimeDelta::FromMilliseconds(kUpdateDelay)));
 }
 
 void RenderViewHostTargetsUIHandler::UpdateTargets() {
-  scoped_ptr<ListValue> list_value(new ListValue());
+  scoped_ptr<base::ListValue> list_value(new base::ListValue());
 
-  std::map<WebContents*, DictionaryValue*> web_contents_to_descriptor_;
+  std::map<WebContents*, base::DictionaryValue*> web_contents_to_descriptor_;
   std::vector<DevToolsTargetImpl*> guest_targets;
 
   DevToolsTargetImpl::List targets =
       DevToolsTargetImpl::EnumerateRenderViewHostTargets();
 
   STLDeleteValues(&targets_);
   for (DevToolsTargetImpl::List::iterator it = targets.begin();
       it != targets.end(); ++it) {
     scoped_ptr<DevToolsTargetImpl> target(*it);
     content::RenderViewHost* rvh = target->GetRenderViewHost();
     if (!rvh)
       continue;
     WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
     if (!web_contents)
       continue;
 
     DevToolsTargetImpl* target_ptr = target.get();
     targets_[target_ptr->GetId()] = target.release();
     if (rvh->GetProcess()->IsGuest()) {
       guest_targets.push_back(target_ptr);
     } else {
-      DictionaryValue* descriptor = Serialize(*target_ptr);
+      base::DictionaryValue* descriptor = Serialize(*target_ptr);
       list_value->Append(descriptor);
       web_contents_to_descriptor_[web_contents] = descriptor;
     }
   }
 
   // Add the list of guest-views to each of its embedders.
   for (std::vector<DevToolsTargetImpl*>::iterator it(guest_targets.begin());
        it != guest_targets.end(); ++it) {
     DevToolsTargetImpl* guest = (*it);
     WebContents* guest_web_contents =
         WebContents::FromRenderViewHost(guest->GetRenderViewHost());
     WebContents* embedder = guest_web_contents->GetEmbedderWebContents();
     if (embedder && web_contents_to_descriptor_.count(embedder) > 0) {
-      DictionaryValue* parent = web_contents_to_descriptor_[embedder];
-      ListValue* guests = NULL;
+      base::DictionaryValue* parent = web_contents_to_descriptor_[embedder];
+      base::ListValue* guests = NULL;
       if (!parent->GetList(kGuestList, &guests)) {
-        guests = new ListValue();
+        guests = new base::ListValue();
         parent->Set(kGuestList, guests);
       }
       guests->Append(Serialize(*guest));
     }
   }
 
   SendSerializedTargets(list_value.Pass());
 }
 
 // WorkerObserver -------------------------------------------------------------
@@ skipping 112 matching lines @@
 
 void WorkerTargetsUIHandler::BrowserChildProcessHostDisconnected(
     const content::ChildProcessData& data) {
   if (data.process_type == content::PROCESS_TYPE_WORKER)
     observer_->Enumerate();
 }
 
 void WorkerTargetsUIHandler::UpdateTargets(
     const DevToolsTargetImpl::List& targets) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  scoped_ptr<ListValue> list_value(new ListValue());
+  scoped_ptr<base::ListValue> list_value(new base::ListValue());
   STLDeleteValues(&targets_);
   for (DevToolsTargetImpl::List::const_iterator it = targets.begin();
       it != targets.end(); ++it) {
     DevToolsTargetImpl* target = *it;
     list_value->Append(Serialize(*target));
     targets_[target->GetId()] = target;
   }
   SendSerializedTargets(list_value.Pass());
 }
 
@@ skipping 49 matching lines @@
   PortForwardingController* port_forwarding_controller =
       PortForwardingController::Factory::GetForProfile(profile_);
   PortForwardingController::DevicesStatus port_forwarding_status;
   if (port_forwarding_controller)
     port_forwarding_status =
         port_forwarding_controller->UpdateDeviceList(*devices);
 
   remote_browsers_.clear();
   STLDeleteValues(&targets_);
 
-  scoped_ptr<ListValue> device_list(new ListValue());
+  scoped_ptr<base::ListValue> device_list(new base::ListValue());
   for (DevToolsAdbBridge::RemoteDevices::iterator dit = devices->begin();
        dit != devices->end(); ++dit) {
     DevToolsAdbBridge::RemoteDevice* device = dit->get();
-    DictionaryValue* device_data = new DictionaryValue();
+    base::DictionaryValue* device_data = new base::DictionaryValue();
     device_data->SetString(kAdbModelField, device->GetModel());
     device_data->SetString(kAdbSerialField, device->GetSerial());
     device_data->SetBoolean(kAdbConnectedField, device->IsConnected());
     std::string device_id = base::StringPrintf(
         "device:%s",
         device->GetSerial().c_str());
     device_data->SetString(kTargetIdField, device_id);
-    ListValue* browser_list = new ListValue();
+    base::ListValue* browser_list = new base::ListValue();
     device_data->Set(kAdbBrowsersList, browser_list);
 
     DevToolsAdbBridge::RemoteBrowsers& browsers = device->browsers();
     for (DevToolsAdbBridge::RemoteBrowsers::iterator bit =
         browsers.begin(); bit != browsers.end(); ++bit) {
       DevToolsAdbBridge::RemoteBrowser* browser = bit->get();
-      DictionaryValue* browser_data = new DictionaryValue();
+      base::DictionaryValue* browser_data = new base::DictionaryValue();
       browser_data->SetString(kAdbBrowserNameField, browser->display_name());
       browser_data->SetString(kAdbBrowserVersionField, browser->version());
       DevToolsAdbBridge::RemoteBrowser::ParsedVersion parsed =
           browser->GetParsedVersion();
       browser_data->SetInteger(
           kAdbBrowserChromeVersionField,
           browser->IsChrome() && !parsed.empty() ? parsed[0] : 0);
       std::string browser_id = base::StringPrintf(
           "browser:%s:%s:%s:%s",
           device->GetSerial().c_str(), // Ensure uniqueness across devices.
           browser->display_name().c_str(),  // Sort by display name.
           browser->version().c_str(),  // Then by version.
           browser->socket().c_str());  // Ensure uniqueness on the device.
       browser_data->SetString(kTargetIdField, browser_id);
       browser_data->SetString(kTargetSourceField, source_id());
       remote_browsers_[browser_id] = browser;
-      ListValue* page_list = new ListValue();
+      base::ListValue* page_list = new base::ListValue();
       browser_data->Set(kAdbPagesList, page_list);
 
       DevToolsTargetImpl::List pages = browser->CreatePageTargets();
       for (DevToolsTargetImpl::List::iterator it =
           pages.begin(); it != pages.end(); ++it) {
         DevToolsTargetImpl* target =  *it;
-        DictionaryValue* target_data = Serialize(*target);
+        base::DictionaryValue* target_data = Serialize(*target);
         target_data->SetBoolean(
             kAdbAttachedForeignField,
             target->IsAttached() &&
                 !DevToolsAdbBridge::HasDevToolsWindow(target->GetId()));
         // Pass the screen size in the target object to make sure that
         // the caching logic does not prevent the target item from updating
         // when the screen size changes.
         gfx::Size screen_size = device->screen_size();
         target_data->SetInteger(kAdbScreenWidthField, screen_size.width());
         target_data->SetInteger(kAdbScreenHeightField, screen_size.height());
         targets_[target->GetId()] = target;
         page_list->Append(target_data);
       }
       browser_list->Append(browser_data);
     }
 
     if (port_forwarding_controller) {
       PortForwardingController::DevicesStatus::iterator sit =
           port_forwarding_status.find(device->GetSerial());
       if (sit != port_forwarding_status.end()) {
-        DictionaryValue* port_status_dict = new DictionaryValue();
+        base::DictionaryValue* port_status_dict = new base::DictionaryValue();
         typedef PortForwardingController::PortStatusMap StatusMap;
         const StatusMap& port_status = sit->second;
         for (StatusMap::const_iterator it = port_status.begin();
              it != port_status.end(); ++it) {
           port_status_dict->SetInteger(
               base::StringPrintf("%d", it->first), it->second);
         }
         device_data->Set(kAdbPortStatus, port_status_dict);
       }
     }
@@ skipping 55 matching lines @@
 
 void DevToolsTargetsUIHandler::Reload(const std::string& target_id) {
   TargetMap::iterator it = targets_.find(target_id);
   if (it != targets_.end())
     it->second->Reload();
 }
 
 base::DictionaryValue*
 DevToolsTargetsUIHandler::Serialize(
     const DevToolsTargetImpl& target) {
-  DictionaryValue* target_data = new DictionaryValue();
+  base::DictionaryValue* target_data = new base::DictionaryValue();
   target_data->SetString(kTargetSourceField, source_id_);
   target_data->SetString(kTargetIdField, target.GetId());
   target_data->SetString(kTargetTypeField, target.GetType());
   target_data->SetBoolean(kAttachedField, target.IsAttached());
   target_data->SetString(kUrlField, target.GetUrl().spec());
   target_data->SetString(kNameField, net::EscapeForHTML(target.GetTitle()));
   target_data->SetString(kFaviconUrlField, target.GetFaviconUrl().spec());
   target_data->SetString(kDescriptionField, target.GetDescription());
   return target_data;
 }
 
 void DevToolsTargetsUIHandler::SendSerializedTargets(
-    scoped_ptr<ListValue> list) {
+    scoped_ptr<base::ListValue> list) {
   callback_.Run(source_id_, list.Pass());
 }
 
 // DevToolsRemoteTargetsUIHandler ---------------------------------------------
 
 DevToolsRemoteTargetsUIHandler::DevToolsRemoteTargetsUIHandler(
     const std::string& source_id,
     Callback callback)
     : DevToolsTargetsUIHandler(source_id, callback) {
 }
 
 // static
 scoped_ptr<DevToolsRemoteTargetsUIHandler>
 DevToolsRemoteTargetsUIHandler::CreateForAdb(
     DevToolsTargetsUIHandler::Callback callback, Profile* profile) {
   return scoped_ptr<DevToolsRemoteTargetsUIHandler>(
       new AdbTargetsUIHandler(callback, profile));
 }