Reland of Move tracing namespace from base::debug to base::trace_event.

base/trace_event/trace_event_android.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 "base/trace_event/trace_event_impl.h"
 
 #include <fcntl.h>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 
 namespace {
 
 int g_atrace_fd = -1;
 const char kATraceMarkerFile[] = "/sys/kernel/debug/tracing/trace_marker";
 
 void WriteEvent(
     char phase,
     const char* category_group,
     const char* name,
     unsigned long long id,
     const char** arg_names,
     const unsigned char* arg_types,
-    const base::debug::TraceEvent::TraceValue* arg_values,
-    const scoped_refptr<base::debug::ConvertableToTraceFormat>*
+    const base::trace_event::TraceEvent::TraceValue* arg_values,
+    const scoped_refptr<base::trace_event::ConvertableToTraceFormat>*
         convertable_values,
     unsigned char flags) {
   std::string out = base::StringPrintf("%c|%d|%s", phase, getpid(), name);
   if (flags & TRACE_EVENT_FLAG_HAS_ID)
     base::StringAppendF(&out, "-%" PRIx64, static_cast<uint64>(id));
   out += '|';
 
-  for (int i = 0; i < base::debug::kTraceMaxNumArgs && arg_names[i]; ++i) {
+  for (int i = 0; i < base::trace_event::kTraceMaxNumArgs && arg_names[i];
+       ++i) {
     if (i)
       out += ';';
     out += arg_names[i];
     out += '=';
     std::string::size_type value_start = out.length();
     if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
       convertable_values[i]->AppendAsTraceFormat(&out);
     } else {
-      base::debug::TraceEvent::AppendValueAsJSON(
-          arg_types[i], arg_values[i], &out);
+      base::trace_event::TraceEvent::AppendValueAsJSON(arg_types[i],
+                                                       arg_values[i], &out);
     }
     // Remove the quotes which may confuse the atrace script.
     ReplaceSubstringsAfterOffset(&out, value_start, "\\\"", "'");
     ReplaceSubstringsAfterOffset(&out, value_start, "\"", "");
     // Replace chars used for separators with similar chars in the value.
     std::replace(out.begin() + value_start, out.end(), ';', ',');
     std::replace(out.begin() + value_start, out.end(), '|', '!');
   }
 
   out += '|';
   out += category_group;
   write(g_atrace_fd, out.c_str(), out.size());
 }
 
 void NoOpOutputCallback(base::WaitableEvent* complete_event,
                         const scoped_refptr<base::RefCountedString>&,
                         bool has_more_events) {
   if (!has_more_events)
     complete_event->Signal();
 }
 
-void EndChromeTracing(base::debug::TraceLog* trace_log,
+void EndChromeTracing(base::trace_event::TraceLog* trace_log,
                       base::WaitableEvent* complete_event) {
   trace_log->SetDisabled();
   // Delete the buffered trace events as they have been sent to atrace.
   trace_log->Flush(base::Bind(&NoOpOutputCallback, complete_event));
 }
 
 }  // namespace
 
 namespace base {
-namespace debug {
+namespace trace_event {
 
 // These functions support Android systrace.py when 'webview' category is
 // traced. With the new adb_profile_chrome, we may have two phases:
 // - before WebView is ready for combined tracing, we can use adb_profile_chrome
 //   to trace android categories other than 'webview' and chromium categories.
 //   In this way we can avoid the conflict between StartATrace/StopATrace and
 //   the intents.
 // - TODO(wangxianzhu): after WebView is ready for combined tracing, remove
 //   StartATrace, StopATrace and SendToATrace, and perhaps send Java traces
 //   directly to atrace in trace_event_binding.cc.
@@ skipping 99 matching lines @@
   // trace buffer.
   TimeTicks now = TimeTicks::NowFromSystemTraceTime();
   double now_in_seconds = now.ToInternalValue() / 1000000.0;
   std::string marker = StringPrintf(
       "trace_event_clock_sync: parent_ts=%f\n", now_in_seconds);
   if (write(atrace_fd, marker.c_str(), marker.size()) == -1)
     PLOG(WARNING) << "Couldn't write to " << kATraceMarkerFile;
   close(atrace_fd);
 }
 
-}  // namespace debug
+}  // namespace trace_event
 }  // namespace base