Remove TraceController

chrome/browser/automation/automation_provider.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 "chrome/browser/automation/automation_provider.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 48 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/render_view_host.h"
-#include "content/public/browser/trace_controller.h"
+#include "content/public/browser/tracing_controller.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/login/login_state.h"
 #endif  // defined(OS_CHROMEOS)
 
 using blink::WebFindOptions;
 using base::Time;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::NavigationController;
 using content::RenderViewHost;
-using content::TraceController;
+using content::TracingController;
 using content::WebContents;
 
 namespace {
 
 void PopulateProxyConfig(const DictionaryValue& dict, net::ProxyConfig* pc) {
   DCHECK(pc);
   bool no_proxy = false;
   if (dict.GetBoolean(automation::kJSONProxyNoProxy, &no_proxy)) {
     // Make no changes to the ProxyConfig.
     return;
@@ skipping 269 matching lines @@
 void AutomationProvider::OnChannelConnected(int pid) {
   is_connected_ = true;
 
   // Send a hello message with our current automation protocol version.
   VLOG(2) << "Testing channel connected, sending hello message";
   channel_->Send(new AutomationMsg_Hello(GetProtocolVersion()));
 
   SendInitialLoadMessage();
 }
 
-void AutomationProvider::OnEndTracingComplete() {
-  IPC::Message* reply_message = tracing_data_.reply_message.release();
-  if (reply_message) {
-    AutomationMsg_EndTracing::WriteReplyParams(
-        reply_message, tracing_data_.trace_output.size(), true);
-    Send(reply_message);
-  }
-}
-
-void AutomationProvider::OnTraceDataCollected(
-    const scoped_refptr<base::RefCountedString>& trace_fragment) {
-  tracing_data_.trace_output.push_back(trace_fragment->data());
-}
-
 bool AutomationProvider::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   bool deserialize_success = true;
   IPC_BEGIN_MESSAGE_MAP_EX(AutomationProvider, message, deserialize_success)
     IPC_MESSAGE_HANDLER(AutomationMsg_HandleUnused, HandleUnused)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetProxyConfig, SetProxyConfig)
     IPC_MESSAGE_HANDLER(AutomationMsg_PrintAsync, PrintAsync)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_Find, HandleFindRequest)
     IPC_MESSAGE_HANDLER(AutomationMsg_OverrideEncoding, OverrideEncoding)
     IPC_MESSAGE_HANDLER(AutomationMsg_SelectAll, SelectAll)
     IPC_MESSAGE_HANDLER(AutomationMsg_Cut, Cut)
     IPC_MESSAGE_HANDLER(AutomationMsg_Copy, Copy)
     IPC_MESSAGE_HANDLER(AutomationMsg_Paste, Paste)
     IPC_MESSAGE_HANDLER(AutomationMsg_ReloadAsync, ReloadAsync)
     IPC_MESSAGE_HANDLER(AutomationMsg_StopAsync, StopAsync)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetPageFontSize, OnSetPageFontSize)
     IPC_MESSAGE_HANDLER(AutomationMsg_SaveAsAsync, SaveAsAsync)
     IPC_MESSAGE_HANDLER(AutomationMsg_RemoveBrowsingData, RemoveBrowsingData)
     IPC_MESSAGE_HANDLER(AutomationMsg_JavaScriptStressTestControl,
                         JavaScriptStressTestControl)
     IPC_MESSAGE_HANDLER(AutomationMsg_BeginTracing, BeginTracing)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_EndTracing, EndTracing)
-    IPC_MESSAGE_HANDLER(AutomationMsg_GetTracingOutput, GetTracingOutput)
 #if defined(OS_WIN)
     // These are for use with external tabs.
     IPC_MESSAGE_HANDLER(AutomationMsg_CreateExternalTab, CreateExternalTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_ProcessUnhandledAccelerator,
                         ProcessUnhandledAccelerator)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetInitialFocus, SetInitialFocus)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabReposition, OnTabReposition)
     IPC_MESSAGE_HANDLER(AutomationMsg_ForwardContextMenuCommandToChrome,
                         OnForwardContextMenuCommandToChrome)
     IPC_MESSAGE_HANDLER(AutomationMsg_NavigateInExternalTab,
@@ skipping 289 matching lines @@
     NOTREACHED();
     return;
   }
 
   view->Send(new ChromeViewMsg_JavaScriptStressTestControl(
       view->GetRoutingID(), cmd, param));
 }
 
 void AutomationProvider::BeginTracing(const std::string& category_patterns,
                                       bool* success) {
-  tracing_data_.trace_output.clear();
-  *success = TraceController::GetInstance()->BeginTracing(
-      this,
-      category_patterns,
-      base::debug::TraceLog::RECORD_UNTIL_FULL);
+  *success = TracingController::GetInstance()->EnableRecording(
+      category_patterns, TracingController::DEFAULT_OPTIONS,
+      TracingController::EnableRecordingDoneCallback());
 }
 
 void AutomationProvider::EndTracing(IPC::Message* reply_message) {
-  bool success = false;
-  if (!tracing_data_.reply_message.get())
-    success = TraceController::GetInstance()->EndTracingAsync(this);
-  if (success) {
-    // Defer EndTracing reply until TraceController calls us back with all the
-    // events.
-    tracing_data_.reply_message.reset(reply_message);
-  } else {
+  base::FilePath path;
+  if (!TracingController::GetInstance()->DisableRecording(
+      path, base::Bind(&AutomationProvider::OnTraceDataCollected, this,
+                       reply_message))) {
     // If failed to call EndTracingAsync, need to reply with failure now.
-    AutomationMsg_EndTracing::WriteReplyParams(reply_message, size_t(0), false);
+    AutomationMsg_EndTracing::WriteReplyParams(reply_message, path, false);
+    Send(reply_message);
+  }
+  // Otherwise defer EndTracing reply until TraceController calls us back.
+}
+
+void AutomationProvider::OnTraceDataCollected(IPC::Message* reply_message,
+                                              const base::FilePath& path) {
+  if (reply_message) {
+    AutomationMsg_EndTracing::WriteReplyParams(reply_message, path, true);
     Send(reply_message);
   }
 }
 
-void AutomationProvider::GetTracingOutput(std::string* chunk,
-                                          bool* success) {
-  // The JSON data is sent back to the test in chunks, because IPC sends will
-  // fail if they are too large.
-  if (tracing_data_.trace_output.empty()) {
-    *chunk = "";
-    *success = false;
-  } else {
-    *chunk = tracing_data_.trace_output.front();
-    tracing_data_.trace_output.pop_front();
-    *success = true;
-  }
-}
-
 RenderViewHost* AutomationProvider::GetViewForTab(int tab_handle) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
     NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     if (!tab) {
       NOTREACHED();
       return NULL;
     }
 
     WebContents* web_contents = tab->GetWebContents();
     if (!web_contents) {
       NOTREACHED();
       return NULL;
     }
 
     RenderViewHost* view_host = web_contents->GetRenderViewHost();
     return view_host;
   }
 
   return NULL;
 }
 
 void AutomationProvider::SaveAsAsync(int tab_handle) {
   NavigationController* tab = NULL;
   WebContents* web_contents = GetWebContentsForHandle(tab_handle, &tab);
   if (web_contents)
     web_contents->OnSavePage();
 }