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

content/browser/tracing/tracing_ui.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/tracing/tracing_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 59 matching lines @@
                             void* params);
   virtual void FileSelectionCanceled(void* params);
 
   // TraceSubscriber implementation.
   virtual void OnEndTracingComplete();
   virtual void OnTraceDataCollected(
       const scoped_refptr<base::RefCountedString>& trace_fragment);
   virtual void OnTraceBufferPercentFullReply(float percent_full);
 
   // Messages.
-  void OnTracingControllerInitialized(const ListValue* list);
-  void OnBeginTracing(const ListValue* list);
-  void OnEndTracingAsync(const ListValue* list);
-  void OnBeginRequestBufferPercentFull(const ListValue* list);
-  void OnLoadTraceFile(const ListValue* list);
-  void OnSaveTraceFile(const ListValue* list);
+  void OnTracingControllerInitialized(const base::ListValue* list);
+  void OnBeginTracing(const base::ListValue* list);
+  void OnEndTracingAsync(const base::ListValue* list);
+  void OnBeginRequestBufferPercentFull(const base::ListValue* list);
+  void OnLoadTraceFile(const base::ListValue* list);
+  void OnSaveTraceFile(const base::ListValue* list);
 
   // Callbacks.
   void LoadTraceFileComplete(string16* file_contents);
   void SaveTraceFileComplete();
 
  private:
   // The file dialog to select a file for loading or saving traces.
   scoped_refptr<ui::SelectFileDialog> select_trace_file_dialog_;
 
   // The type of the file dialog as the same one is used for loading or saving
@@ skipping 88 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("loadTraceFile",
       base::Bind(&TracingMessageHandler::OnLoadTraceFile,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("saveTraceFile",
       base::Bind(&TracingMessageHandler::OnSaveTraceFile,
                  base::Unretained(this)));
 }
 
 void TracingMessageHandler::OnTracingControllerInitialized(
-    const ListValue* args) {
+    const base::ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Send the client info to the tracingController
   {
-    scoped_ptr<DictionaryValue> dict(new DictionaryValue());
+    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("version", GetContentClient()->GetProduct());
 
     dict->SetString("command_line",
         CommandLine::ForCurrentProcess()->GetCommandLineString());
 
     web_ui()->CallJavascriptFunction("tracingController.onClientInfoUpdate",
                                      *dict);
   }
 }
 
 void TracingMessageHandler::OnBeginRequestBufferPercentFull(
-    const ListValue* list) {
+    const base::ListValue* list) {
   TraceController::GetInstance()->GetTraceBufferPercentFullAsync(this);
 }
 
 // A callback used for asynchronously reading a file to a string. Calls the
 // TaskProxy callback when reading is complete.
 void ReadTraceFileCallback(TaskProxy* proxy, const base::FilePath& path) {
   std::string file_contents;
   if (!file_util::ReadFileToString(path, &file_contents))
     return;
 
@@ skipping 69 matching lines @@
   if (select_trace_file_dialog_type_ ==
       ui::SelectFileDialog::SELECT_OPEN_FILE) {
     web_ui()->CallJavascriptFunction(
         "tracingController.onLoadTraceFileCanceled");
   } else {
     web_ui()->CallJavascriptFunction(
         "tracingController.onSaveTraceFileCanceled");
   }
 }
 
-void TracingMessageHandler::OnLoadTraceFile(const ListValue* list) {
+void TracingMessageHandler::OnLoadTraceFile(const base::ListValue* list) {
   // Only allow a single dialog at a time.
   if (select_trace_file_dialog_.get())
     return;
   select_trace_file_dialog_type_ = ui::SelectFileDialog::SELECT_OPEN_FILE;
   select_trace_file_dialog_ = ui::SelectFileDialog::Create(
       this,
       GetContentClient()->browser()->CreateSelectFilePolicy(
           web_ui()->GetWebContents()));
   select_trace_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_OPEN_FILE,
@@ skipping 21 matching lines @@
   for (size_t i = 0; i < contents->size(); i += kMaxSize) {
     string16 javascript = i == 0 ? first_prefix : prefix;
     javascript += contents->substr(i, kMaxSize) + suffix;
     rvh->ExecuteJavascriptInWebFrame(string16(), javascript);
   }
   rvh->ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(
       "tracingController.onLoadTraceFileComplete(JSON.parse(window.traceData));"
       "delete window.traceData;"));
 }
 
-void TracingMessageHandler::OnSaveTraceFile(const ListValue* list) {
+void TracingMessageHandler::OnSaveTraceFile(const base::ListValue* list) {
   // Only allow a single dialog at a time.
   if (select_trace_file_dialog_.get())
     return;
 
   DCHECK(list->GetSize() == 1);
 
   std::string* trace_data = new std::string();
   bool ok = list->GetString(0, trace_data);
   DCHECK(ok);
   trace_data_to_save_.reset(trace_data);
 
   select_trace_file_dialog_type_ = ui::SelectFileDialog::SELECT_SAVEAS_FILE;
   select_trace_file_dialog_ = ui::SelectFileDialog::Create(
       this,
       GetContentClient()->browser()->CreateSelectFilePolicy(
           web_ui()->GetWebContents()));
   select_trace_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_SAVEAS_FILE,
       string16(),
       base::FilePath(),
       NULL, 0, FILE_PATH_LITERAL(""),
       web_ui()->GetWebContents()->GetView()->GetTopLevelNativeWindow(), NULL);
 }
 
 void TracingMessageHandler::SaveTraceFileComplete() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   web_ui()->CallJavascriptFunction("tracingController.onSaveTraceFileComplete");
 }
 
-void TracingMessageHandler::OnBeginTracing(const ListValue* args) {
+void TracingMessageHandler::OnBeginTracing(const base::ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(args->GetSize(), (size_t) 2);
 
   bool system_tracing_requested = false;
   bool ok = args->GetBoolean(0, &system_tracing_requested);
   DCHECK(ok);
 
   std::string chrome_categories;
   ok = args->GetString(1, &chrome_categories);
   DCHECK(ok);
 
   trace_enabled_ = true;
   // TODO(jbates) This may fail, but that's OK for current use cases.
   //              Ex: Multiple about:gpu traces can not trace simultaneously.
   // TODO(nduca) send feedback to javascript about whether or not BeginTracing
   //             was successful.
   TraceController::GetInstance()->BeginTracing(this, chrome_categories);
 
   if (system_tracing_requested) {
 #if defined(OS_CHROMEOS)
     DCHECK(!system_trace_in_progress_);
     chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->
         StartSystemTracing();
     // TODO(sleffler) async, could wait for completion
     system_trace_in_progress_ = true;
 #endif
   }
 }
 
-void TracingMessageHandler::OnEndTracingAsync(const ListValue* list) {
+void TracingMessageHandler::OnEndTracingAsync(const base::ListValue* list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // TODO(nduca): fix javascript code to make sure trace_enabled_ is always true
   //              here. triggered a false condition by just clicking stop
   //              trace a few times when it was going slow, and maybe switching
   //              between tabs.
   if (trace_enabled_ &&
       !TraceController::GetInstance()->EndTracingAsync(this)) {
     // Set to false now, since it turns out we never were the trace subscriber.
     OnEndTracingComplete();
@@ skipping 21 matching lines @@
   }
   web_ui()->CallJavascriptFunction("tracingController.onEndTracingComplete");
 }
 
 void TracingMessageHandler::OnEndSystemTracingAck(
     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   web_ui()->CallJavascriptFunction(
       "tracingController.onSystemTraceDataCollected",
-      *scoped_ptr<Value>(Value::CreateStringValue(events_str_ptr->data())));
+      *scoped_ptr<base::Value>(new base::StringValue(events_str_ptr->data())));
   DCHECK(!system_trace_in_progress_);
 
   OnEndTracingComplete();
 }
 
 void TracingMessageHandler::OnTraceDataCollected(
     const scoped_refptr<base::RefCountedString>& trace_fragment) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::debug::TraceResultBuffer::SimpleOutput output;
   base::debug::TraceResultBuffer trace_buffer;
   trace_buffer.SetOutputCallback(output.GetCallback());
   output.Append("tracingController.onTraceDataCollected(");
   trace_buffer.Start();
   trace_buffer.AddFragment(trace_fragment->data());
   trace_buffer.Finish();
   output.Append(");");
 
   web_ui()->GetWebContents()->GetRenderViewHost()->
       ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(output.json_output));
 }
 
 void TracingMessageHandler::OnTraceBufferPercentFullReply(float percent_full) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   web_ui()->CallJavascriptFunction(
       "tracingController.onRequestBufferPercentFullComplete",
-      *scoped_ptr<Value>(Value::CreateDoubleValue(percent_full)));
+      *scoped_ptr<base::Value>(new base::FundamentalValue(percent_full)));
 }
 
 }  // namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TracingUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TracingUI::TracingUI(WebUI* web_ui) : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new TracingMessageHandler());
 
   // Set up the chrome://tracing/ source.
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, CreateTracingHTMLSource());
 }
 
 }  // namespace content