Stop using the TRACE_EVENT_*_ETW macros.

content/common/sandbox_win.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/common/sandbox_win.h"
 
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 635 matching lines @@
   return sandbox::SBOX_ALL_OK == result;
 }
 
 base::Process StartSandboxedProcess(
     SandboxedProcessLauncherDelegate* delegate,
     base::CommandLine* cmd_line) {
   const base::CommandLine& browser_command_line =
       *base::CommandLine::ForCurrentProcess();
   std::string type_str = cmd_line->GetSwitchValueASCII(switches::kProcessType);
 
-  TRACE_EVENT_BEGIN_ETW("StartProcessWithAccess", 0, type_str);
+  TRACE_EVENT1("startup", "StartProcessWithAccess", "type", type_str);
 
   // Propagate the --allow-no-job flag if present.
   if (browser_command_line.HasSwitch(switches::kAllowNoSandboxJob) &&
       !cmd_line->HasSwitch(switches::kAllowNoSandboxJob)) {
     cmd_line->AppendSwitch(switches::kAllowNoSandboxJob);
   }
 
   ProcessDebugFlags(cmd_line);
 
   // Prefetch hints on windows:
@@ skipping 121 matching lines @@
   policy->SetStderrHandle(GetStdHandle(STD_ERROR_HANDLE));
 #endif
 
   if (delegate) {
     bool success = true;
     delegate->PreSpawnTarget(policy, &success);
     if (!success)
       return base::Process();
   }
 
-  TRACE_EVENT_BEGIN_ETW("StartProcessWithAccess::LAUNCHPROCESS", 0, 0);
+  TRACE_EVENT_BEGIN0("startup", "StartProcessWithAccess::LAUNCHPROCESS");
 
   PROCESS_INFORMATION temp_process_info = {};
   result = g_broker_services->SpawnTarget(
-               cmd_line->GetProgram().value().c_str(),
-               cmd_line->GetCommandLineString().c_str(),
-               policy, &temp_process_info);
+      cmd_line->GetProgram().value().c_str(),
+      cmd_line->GetCommandLineString().c_str(), policy, &temp_process_info);
   DWORD last_error = ::GetLastError();
   base::win::ScopedProcessInformation target(temp_process_info);
 
-  TRACE_EVENT_END_ETW("StartProcessWithAccess::LAUNCHPROCESS", 0, 0);
+  TRACE_EVENT_END0("startup", "StartProcessWithAccess::LAUNCHPROCESS");
 
   if (sandbox::SBOX_ALL_OK != result) {
     if (result == sandbox::SBOX_ERROR_GENERIC)
       DPLOG(ERROR) << "Failed to launch process";
     else if (result == sandbox::SBOX_ERROR_CREATE_PROCESS) {
       // TODO(shrikant): Remove this special case handling after determining
       // cause for lowbox/createprocess errors.
       sandbox::PolicyBase* policy_base =
           static_cast<sandbox::PolicyBase*>(policy);
       UMA_HISTOGRAM_SPARSE_SLOWLY(policy_base->GetLowBoxSid() ?
                                       "Process.Sandbox.Lowbox.Launch.Error" :
                                       "Process.Sandbox.Launch.Error",
                                   last_error);
     } else
       DLOG(ERROR) << "Failed to launch process. Error: " << result;
 
     policy->Release();
     return base::Process();
   }
   policy->Release();
 
   if (delegate)
     delegate->PostSpawnTarget(target.process_handle());
 
   CHECK(ResumeThread(target.thread_handle()) != -1);
-  TRACE_EVENT_END_ETW("StartProcessWithAccess", 0, type_str);
   return base::Process(target.TakeProcessHandle());
 }
 
 bool BrokerDuplicateHandle(HANDLE source_handle,
                            DWORD target_process_id,
                            HANDLE* target_handle,
                            DWORD desired_access,
                            DWORD options) {
   // If our process is the target just duplicate the handle.
   if (::GetCurrentProcessId() == target_process_id) {
@@ skipping 22 matching lines @@
   }
 
   return false;
 }
 
 bool BrokerAddTargetPeer(HANDLE peer_process) {
   return g_broker_services->AddTargetPeer(peer_process) == sandbox::SBOX_ALL_OK;
 }
 
 }  // namespace content