Added trace query code and wired tracing through BrowserProxy so tests can run traces.

chrome/browser/automation/testing_automation_provider.cc

 // Copyright (c) 2011 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/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 233 matching lines @@
 void TestingAutomationProvider::Observe(int type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_SESSION_END);
   // OnBrowserRemoved does a ReleaseLater. When session end is received we exit
   // before the task runs resulting in this object not being deleted. This
   // Release balance out the Release scheduled by OnBrowserRemoved.
   Release();
 }
 
+void TestingAutomationProvider::OnEndTracingComplete() {
+  IPC::Message* reply_message = tracing_data_.reply_message.release();
+  if (reply_message) {
+    // Finish off JSON string.
+    if (tracing_data_.json_output.empty())
+      tracing_data_.json_output.push_back("[]");
+    else
+      tracing_data_.json_output.push_back("]");
+    AutomationMsg_EndTracing::WriteReplyParams(reply_message, true);
+    Send(reply_message);
+  }
+}
+
+void TestingAutomationProvider::OnTraceDataCollected(
+    const std::string& json_events) {
+  // |json_events| should start with '[' and end with ']'.
+  if (json_events.size() > 2) {
+    std::string chunk;
+    // If this is the first chunk, JSON starts with '['.
+    if (tracing_data_.json_output.empty())
+      chunk += '[';
+    else
+      chunk += ',';
+    chunk += json_events.substr(1, json_events.size() - 2);
+    // Append without the leading and trailing brackets.
+    tracing_data_.json_output.push_back(chunk);
+  }
+}
+
 bool TestingAutomationProvider::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   bool deserialize_success = true;
   IPC_BEGIN_MESSAGE_MAP_EX(TestingAutomationProvider,
                            message,
                            deserialize_success)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseBrowser, CloseBrowser)
     IPC_MESSAGE_HANDLER(AutomationMsg_CloseBrowserRequestAsync,
                         CloseBrowserAsync)
@@ skipping 40 matching lines @@
     IPC_MESSAGE_HANDLER(AutomationMsg_GetWindowBounds, GetWindowBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowBounds, SetWindowBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowVisible, SetWindowVisible)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowClick, WindowSimulateClick)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowMouseMove, WindowSimulateMouseMove)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowKeyPress, WindowSimulateKeyPress)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabCount, GetTabCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_Type, GetType)
     IPC_MESSAGE_HANDLER(AutomationMsg_IsBrowserInApplicationMode,
                         IsBrowserInApplicationMode)
+    IPC_MESSAGE_HANDLER(AutomationMsg_BeginTracing, BeginTracing)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_EndTracing, EndTracing)
+    IPC_MESSAGE_HANDLER(AutomationMsg_GetTracingOutput, GetTracingOutput)
     IPC_MESSAGE_HANDLER(AutomationMsg_Tab, GetTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabProcessID, GetTabProcessID)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabTitle, GetTabTitle)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabIndex, GetTabIndex)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabURL, GetTabURL)
     IPC_MESSAGE_HANDLER(AutomationMsg_ShelfVisibility, GetShelfVisibility)
     IPC_MESSAGE_HANDLER(AutomationMsg_IsFullscreen, IsFullscreen)
     IPC_MESSAGE_HANDLER(AutomationMsg_IsFullscreenBubbleVisible,
                         GetFullscreenBubbleVisibility)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_DomOperation,
@@ skipping 866 matching lines @@
 
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
       *success = true;
       *is_application = browser->is_app();
     }
   }
 }
 
+void TestingAutomationProvider::BeginTracing(
+    const std::vector<std::string>& included_categories,
+    const std::vector<std::string>& excluded_categories,
+    bool* result) {
+  tracing_data_.json_output.clear();
+  *result = TraceController::GetInstance()->BeginTracing(this,
+                                                         included_categories,
+                                                         excluded_categories);
+}
+
+void TestingAutomationProvider::EndTracing(IPC::Message* reply_message) {
+  bool success = false;
+  if (!tracing_data_.reply_message.get()) {
+    success = TraceController::GetInstance()->EndTracingAsync(this);
+  }
+  // If failed to call EndTracingAsync, need to reply with failure now.
+  if (!success) {
+    AutomationMsg_EndTracing::WriteReplyParams(reply_message, false);
+    Send(reply_message);
+  } else {
+    // Defer EndTracing reply until the we are notified by TraceController.
+    tracing_data_.reply_message.reset(reply_message);
+  }
+}
+
+void TestingAutomationProvider::GetTracingOutput(std::string* chunk,
+                                                 int* remaining_chunks) {
+  // The JSON data is sent back to the test in chunks, because IPC sends will
+  // fail if they are too large.
+  if (tracing_data_.json_output.empty()) {
+    *chunk = "";
+    *remaining_chunks = -1;
+  } else {
+    *chunk = tracing_data_.json_output.front();
+    tracing_data_.json_output.pop_front();
+    *remaining_chunks = tracing_data_.json_output.size();
+  }
+}
+
 void TestingAutomationProvider::GetTab(int win_handle,
                                        int tab_index,
                                        int* tab_handle) {
   *tab_handle = 0;
   if (browser_tracker_->ContainsHandle(win_handle) && (tab_index >= 0)) {
     Browser* browser = browser_tracker_->GetResource(win_handle);
     if (tab_index < browser->tab_count()) {
       TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
       *tab_handle = tab_tracker_->Add(&tab_contents->controller());
     }
@@ skipping 5131 matching lines @@
   IPC::ParamTraits<std::vector<GURL> >::Write(reply_message_, redirects_gurl);
 
   Send(reply_message_);
   redirect_query_ = 0;
   reply_message_ = NULL;
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   AutomationProviderList::GetInstance()->RemoveProvider(this);
 }