Cleanup: Remove deprecated base::Value methods from contents. Use base::Value too.

content/browser/devtools/devtools_http_handler_impl.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 "content/browser/devtools/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 494 matching lines @@
   if (!ParseJsonPath(path, &command, &target_id)) {
     SendJson(connection_id,
              net::HTTP_NOT_FOUND,
              NULL,
              "Malformed query: " + info.path,
              jsonp);
     return;
   }
 
   if (command == "version") {
-    DictionaryValue version;
+    base::DictionaryValue version;
     version.SetString("Protocol-Version",
                       WebKit::WebDevToolsAgent::inspectorProtocolVersion());
     version.SetString("WebKit-Version",
                       webkit_glue::GetWebKitVersion());
     version.SetString("Browser",
                       content::GetContentClient()->GetProduct());
     version.SetString("User-Agent",
                       webkit_glue::GetUserAgent(GURL(chrome::kAboutBlankURL)));
     SendJson(connection_id, net::HTTP_OK, &version, "", jsonp);
     return;
   }
 
   if (command == "list") {
     PageList page_list = GeneratePageList();
-    ListValue json_pages_list;
+    base::ListValue json_pages_list;
     std::string host = info.headers["Host"];
     for (PageList::iterator i = page_list.begin(); i != page_list.end(); ++i)
       json_pages_list.Append(SerializePageInfo(*i, host));
     SendJson(connection_id, net::HTTP_OK, &json_pages_list, "", jsonp);
     return;
   }
 
   if (command == "new") {
     RenderViewHost* rvh = delegate_->CreateNewTarget();
     if (!rvh) {
       SendJson(connection_id,
                net::HTTP_INTERNAL_SERVER_ERROR,
                NULL,
                "Could not create new page",
                jsonp);
       return;
     }
-    PageInfo page_info = CreatePageInfo(
-        rvh,
-        DevToolsHttpHandlerDelegate::kTargetTypeTab);
+    PageInfo page_info =
+        CreatePageInfo(rvh, DevToolsHttpHandlerDelegate::kTargetTypeTab);
     std::string host = info.headers["Host"];
-    scoped_ptr<DictionaryValue> dictionary(SerializePageInfo(page_info, host));
+    scoped_ptr<base::DictionaryValue> dictionary(
+        SerializePageInfo(page_info, host));
     SendJson(connection_id, net::HTTP_OK, dictionary.get(), "", jsonp);
     return;
   }
 
   if (command == "activate" || command == "close") {
     DevToolsAgentHost* agent_host = binding_->ForIdentifier(target_id);
     RenderViewHost* rvh = agent_host ? agent_host->GetRenderViewHost() : NULL;
     if (!rvh) {
       SendJson(connection_id,
                net::HTTP_NOT_FOUND,
@@ skipping 178 matching lines @@
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&DevToolsHttpHandlerImpl::Teardown, this));
   // Thread::Stop joins the thread.
   thread_->Stop();
 }
 
 void DevToolsHttpHandlerImpl::SendJson(int connection_id,
                                        net::HttpStatusCode status_code,
-                                       Value* value,
+                                       base::Value* value,
                                        const std::string& message,
                                        const std::string& jsonp) {
   if (!thread_.get())
     return;
 
   // Serialize value and message.
   std::string json_value;
   if (value) {
     base::JSONWriter::WriteWithOptions(value,
                                        base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                        &json_value);
   }
   std::string json_message;
-  scoped_ptr<Value> message_object(Value::CreateStringValue(message));
+  scoped_ptr<base::Value> message_object(new base::StringValue(message));
   base::JSONWriter::Write(message_object.get(), &json_message);
 
   std::string response;
   std::string mime_type = "application/json; charset=UTF-8";
 
   // Wrap jsonp if necessary.
   if (!jsonp.empty()) {
     mime_type = "text/javascript; charset=UTF-8";
     response = StringPrintf("%s(%s, %d, %s);",
                             jsonp.c_str(),
@@ skipping 89 matching lines @@
     NavigationController& controller = web_contents->GetController();
     NavigationEntry* entry = controller.GetActiveEntry();
     if (entry != NULL && entry->GetURL().is_valid()) {
       page_info.thumbnail_url = "/thumb/" + entry->GetURL().spec();
       page_info.favicon_url = entry->GetFavicon().url.spec();
     }
   }
   return page_info;
 }
 
-DictionaryValue* DevToolsHttpHandlerImpl::SerializePageInfo(
+base::DictionaryValue* DevToolsHttpHandlerImpl::SerializePageInfo(
     const PageInfo& page_info,
     const std::string& host) {
-  DictionaryValue* dictionary = new DictionaryValue;
+  base::DictionaryValue* dictionary = new base::DictionaryValue;
   dictionary->SetString("title", page_info.title);
   dictionary->SetString("url", page_info.url);
   dictionary->SetString("type", page_info.type);
   dictionary->SetString("id", page_info.id);
   dictionary->SetString("thumbnailUrl", page_info.thumbnail_url);
   dictionary->SetString("faviconUrl", page_info.favicon_url);
   if (!page_info.attached) {
     dictionary->SetString("webSocketDebuggerUrl",
                           base::StringPrintf("ws://%s/devtools/page/%s",
                                              host.c_str(),
                                              page_info.id.c_str()));
     std::string devtools_frontend_url = GetFrontendURLInternal(
         page_info.id.c_str(),
         host);
     dictionary->SetString("devtoolsFrontendUrl", devtools_frontend_url);
   }
   return dictionary;
 }
 
 }  // namespace content