Merge gpu_trace_event back into base/debug/trace_event

chrome_frame/chrome_frame_automation.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_frame/chrome_frame_automation.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 111 matching lines @@
         NOTREACHED();
     }
     return true;
   }
 };
 
 ChromeFrameAutomationProxyImpl::ChromeFrameAutomationProxyImpl(
     AutomationProxyCacheEntry* entry,
     std::string channel_id, int launch_timeout)
     : AutomationProxy(launch_timeout, false), proxy_entry_(entry) {
-  TRACE_EVENT_BEGIN("chromeframe.automationproxy", this, "");
+  TRACE_EVENT_BEGIN_ETW("chromeframe.automationproxy", this, "");
 
   InitializeChannel(channel_id, false);
 
   sync_ = new CFMsgDispatcher();
   message_filter_ = new TabProxyNotificationMessageFilter(tracker_.get());
 
   // Order of filters is not important.
   channel_->AddFilter(message_filter_.get());
   channel_->AddFilter(sync_.get());
 }
 
 ChromeFrameAutomationProxyImpl::~ChromeFrameAutomationProxyImpl() {
-  TRACE_EVENT_END("chromeframe.automationproxy", this, "");
+  TRACE_EVENT_END_ETW("chromeframe.automationproxy", this, "");
 }
 
 void ChromeFrameAutomationProxyImpl::SendAsAsync(
     IPC::SyncMessage* msg,
     SyncMessageReplyDispatcher::SyncMessageCallContext* context, void* key) {
   sync_->Push(msg, context, key);
   channel_->ChannelProxy::Send(msg);
 }
 
 void ChromeFrameAutomationProxyImpl::CancelAsync(void* key) {
@@ skipping 191 matching lines @@
           "ChromeFrame.AutomationServerLaunchFailedTime", delta);
     }
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("ChromeFrame.LaunchResult",
                                 launch_result_,
                                 AUTOMATION_SUCCESS,
                                 AUTOMATION_CREATE_TAB_FAILED,
                                 AUTOMATION_CREATE_TAB_FAILED + 1);
   }
 
-  TRACE_EVENT_END("chromeframe.createproxy", this, "");
+  TRACE_EVENT_END_ETW("chromeframe.createproxy", this, "");
 
   // Finally set the proxy.
   proxy_.reset(proxy);
   launch_delegates_.push_back(delegate);
 
   delegate->LaunchComplete(proxy_.get(), launch_result_);
 }
 
 void AutomationProxyCacheEntry::RemoveDelegate(LaunchDelegate* delegate,
                                                base::WaitableEvent* done,
@@ skipping 92 matching lines @@
     DWORD result = proxies_[i]->WaitForThread(0);
     if (WAIT_OBJECT_0 != result)
       // TODO(stoyan): Don't leak proxies on exit.
       DLOG(ERROR) << "Proxies leaked on exit.";
   }
 }
 
 void ProxyFactory::GetAutomationServer(
     LaunchDelegate* delegate, ChromeFrameLaunchParams* params,
     void** automation_server_id) {
-  TRACE_EVENT_BEGIN("chromeframe.createproxy", this, "");
+  TRACE_EVENT_BEGIN_ETW("chromeframe.createproxy", this, "");
 
   scoped_refptr<AutomationProxyCacheEntry> entry;
   // Find already existing launcher thread for given profile
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < proxies_.container().size(); ++i) {
     if (proxies_[i]->IsSameProfile(params->profile_name())) {
       entry = proxies_[i];
       break;
     }
   }
@@ skipping 870 matching lines @@
     const net::URLRequestStatus& status) {
   automation_server_->Send(new AutomationMsg_RequestEnd(
       tab_->handle(), request_id, status));
 }
 
 void ChromeFrameAutomationClient::OnCookiesRetrieved(bool success,
     const GURL& url, const std::string& cookie_string, int cookie_id) {
   automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(
       tab_->handle(), success, url, cookie_string, cookie_id));
 }