Remove base::StringValue

chrome/browser/devtools/devtools_ui_bindings.cc

 // Copyright 2014 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_ui_bindings.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 272 matching lines @@
                           int num_bytes,
                           const net::CompletionCallback& callback) {
   std::string chunk = std::string(buffer->data(), num_bytes);
   bool encoded = false;
   if (!base::IsStringUTF8(chunk)) {
     encoded = true;
     base::Base64Encode(chunk, &chunk);
   }
 
   base::Value* id = new base::Value(stream_id_);
-  base::StringValue* chunkValue = new base::StringValue(chunk);
+  base::Value* chunkValue = new base::Value(chunk);
   base::Value* encodedValue = new base::Value(encoded);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&DevToolsUIBindings::CallClientFunction, bindings_,
                  "DevToolsAPI.streamWrite", base::Owned(id),
                  base::Owned(chunkValue), base::Owned(encodedValue)));
   return num_bytes;
 }
 
@@ skipping 322 matching lines @@
     std::string param;
     base::EscapeJSONString(message, true, &param);
     base::string16 javascript =
         base::UTF8ToUTF16("DevToolsAPI.dispatchMessage(" + param + ");");
     web_contents_->GetMainFrame()->ExecuteJavaScript(javascript);
     return;
   }
 
   base::Value total_size(static_cast<int>(message.length()));
   for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
-    base::StringValue message_value(message.substr(pos, kMaxMessageChunkSize));
+    base::Value message_value(message.substr(pos, kMaxMessageChunkSize));
     CallClientFunction("DevToolsAPI.dispatchMessageChunk",
                        &message_value, pos ? NULL : &total_size, NULL);
   }
 }
 
 void DevToolsUIBindings::AgentHostClosed(
     content::DevToolsAgentHost* agent_host,
     bool replaced_with_another_client) {
   DCHECK(agent_host == agent_host_.get());
   agent_host_ = NULL;
@@ skipping 436 matching lines @@
                  callback));
 }
 
 void DevToolsUIBindings::JsonReceived(const DispatchCallback& callback,
                                       int result,
                                       const std::string& message) {
   if (result != net::OK) {
     callback.Run(nullptr);
     return;
   }
-  base::StringValue message_value(message);
+  base::Value message_value(message);
   callback.Run(&message_value);
 }
 
 void DevToolsUIBindings::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(source);
   PendingRequestsMap::iterator it = pending_requests_.find(source);
   DCHECK(it != pending_requests_.end());
 
   base::DictionaryValue response;
   base::DictionaryValue* headers = new base::DictionaryValue();
@@ skipping 19 matching lines @@
 }
 
 void DevToolsUIBindings::DevicesUpdated(
     const std::string& source,
     const base::ListValue& targets) {
   CallClientFunction("DevToolsAPI.devicesUpdated", &targets, NULL,
                      NULL);
 }
 
 void DevToolsUIBindings::FileSavedAs(const std::string& url) {
-  base::StringValue url_value(url);
+  base::Value url_value(url);
   CallClientFunction("DevToolsAPI.savedURL", &url_value, NULL, NULL);
 }
 
 void DevToolsUIBindings::CanceledFileSaveAs(const std::string& url) {
-  base::StringValue url_value(url);
+  base::Value url_value(url);
   CallClientFunction("DevToolsAPI.canceledSaveURL",
                      &url_value, NULL, NULL);
 }
 
 void DevToolsUIBindings::AppendedTo(const std::string& url) {
-  base::StringValue url_value(url);
+  base::Value url_value(url);
   CallClientFunction("DevToolsAPI.appendedToURL", &url_value, NULL,
                      NULL);
 }
 
 void DevToolsUIBindings::FileSystemAdded(
     const DevToolsFileHelper::FileSystem& file_system) {
   std::unique_ptr<base::DictionaryValue> file_system_value(
       CreateFileSystemValue(file_system));
   CallClientFunction("DevToolsAPI.fileSystemAdded",
                      file_system_value.get(), NULL, NULL);
 }
 
 void DevToolsUIBindings::FileSystemRemoved(
     const std::string& file_system_path) {
-  base::StringValue file_system_path_value(file_system_path);
+  base::Value file_system_path_value(file_system_path);
   CallClientFunction("DevToolsAPI.fileSystemRemoved",
                      &file_system_path_value, NULL, NULL);
 }
 
 void DevToolsUIBindings::FilePathsChanged(
     const std::vector<std::string>& changed_paths,
     const std::vector<std::string>& added_paths,
     const std::vector<std::string>& removed_paths) {
   base::ListValue changed, added, removed;
   changed.AppendStrings(changed_paths);
   added.AppendStrings(added_paths);
   removed.AppendStrings(removed_paths);
 
   CallClientFunction("DevToolsAPI.fileSystemFilesChangedAddedRemoved", &changed,
                      &added, &removed);
 }
 
 void DevToolsUIBindings::IndexingTotalWorkCalculated(
     int request_id,
     const std::string& file_system_path,
     int total_work) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Value request_id_value(request_id);
-  base::StringValue file_system_path_value(file_system_path);
+  base::Value file_system_path_value(file_system_path);
   base::Value total_work_value(total_work);
   CallClientFunction("DevToolsAPI.indexingTotalWorkCalculated",
                      &request_id_value, &file_system_path_value,
                      &total_work_value);
 }
 
 void DevToolsUIBindings::IndexingWorked(int request_id,
                                         const std::string& file_system_path,
                                         int worked) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Value request_id_value(request_id);
-  base::StringValue file_system_path_value(file_system_path);
+  base::Value file_system_path_value(file_system_path);
   base::Value worked_value(worked);
   CallClientFunction("DevToolsAPI.indexingWorked", &request_id_value,
                      &file_system_path_value, &worked_value);
 }
 
 void DevToolsUIBindings::IndexingDone(int request_id,
                                       const std::string& file_system_path) {
   indexing_jobs_.erase(request_id);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Value request_id_value(request_id);
-  base::StringValue file_system_path_value(file_system_path);
+  base::Value file_system_path_value(file_system_path);
   CallClientFunction("DevToolsAPI.indexingDone", &request_id_value,
                      &file_system_path_value, NULL);
 }
 
 void DevToolsUIBindings::SearchCompleted(
     int request_id,
     const std::string& file_system_path,
     const std::vector<std::string>& file_paths) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::ListValue file_paths_value;
   for (std::vector<std::string>::const_iterator it(file_paths.begin());
        it != file_paths.end(); ++it) {
     file_paths_value.AppendString(*it);
   }
   base::Value request_id_value(request_id);
-  base::StringValue file_system_path_value(file_system_path);
+  base::Value file_system_path_value(file_system_path);
   CallClientFunction("DevToolsAPI.searchCompleted", &request_id_value,
                      &file_system_path_value, &file_paths_value);
 }
 
 void DevToolsUIBindings::ShowDevToolsConfirmInfoBar(
     const base::string16& message,
     const InfoBarCallback& callback) {
   if (!delegate_->GetInfoBarService()) {
     callback.Run(false);
     return;
@@ skipping 34 matching lines @@
     // process. Grant each specific extension's origin permission to load
     // documents.
     content::ChildProcessSecurityPolicy::GetInstance()->GrantOrigin(
         web_contents_->GetMainFrame()->GetProcess()->GetID(),
         url::Origin(extension->url()));
 
     std::unique_ptr<base::DictionaryValue> extension_info(
         new base::DictionaryValue());
     extension_info->Set(
         "startPage",
-        new base::StringValue(extensions::chrome_manifest_urls::GetDevToolsPage(
-                                  extension.get()).spec()));
-    extension_info->Set("name", new base::StringValue(extension->name()));
+        new base::Value(
+            extensions::chrome_manifest_urls::GetDevToolsPage(extension.get())
+                .spec()));
+    extension_info->Set("name", new base::Value(extension->name()));
     extension_info->Set(
         "exposeExperimentalAPIs",
         new base::Value(extension->permissions_data()->HasAPIPermission(
             extensions::APIPermission::kExperimental)));
     results.Append(std::move(extension_info));
   }
 
   CallClientFunction("DevToolsAPI.addExtensions",
                      &results, NULL, NULL);
 }
@@ skipping 79 matching lines @@
 void DevToolsUIBindings::FrontendLoaded() {
   if (frontend_loaded_)
     return;
   frontend_loaded_ = true;
 
   // Call delegate first - it seeds importants bit of information.
   delegate_->OnLoadCompleted();
 
   AddDevToolsExtensionsToClient();
 }