Make Chrome Trace work with Android ATrace.

base/debug/trace_event_impl.h

 // 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.
 
 
 #ifndef BASE_DEBUG_TRACE_EVENT_IMPL_H_
 #define BASE_DEBUG_TRACE_EVENT_IMPL_H_
 
 #include "build/build_config.h"
 
@@ skipping 64 matching lines @@
              unsigned char flags);
   ~TraceEvent();
 
   // Serialize event data to JSON
   static void AppendEventsAsJSON(const std::vector<TraceEvent>& events,
                                  size_t start,
                                  size_t count,
                                  std::string* out);
   void AppendAsJSON(std::string* out) const;
 
+  static void AppendValueAsJSON(unsigned char type,
+                                TraceValue value,
+                                std::string* out);
+
   TimeTicks timestamp() const { return timestamp_; }
 
   // Exposed for unittesting:
 
   const base::RefCountedString* parameter_copy_storage() const {
     return parameter_copy_storage_.get();
   }
 
   const unsigned char* category_enabled() const { return category_enabled_; }
   const char* name() const { return name_; }
@@ skipping 102 matching lines @@
   // meaningful if |IsEnabled()| is true.
   void GetEnabledTraceCategories(std::vector<std::string>* included_out,
                                  std::vector<std::string>* excluded_out);
 
   // Disable tracing for all categories.
   void SetDisabled();
   // Helper method to enable/disable tracing for all categories.
   void SetEnabled(bool enabled);
   bool IsEnabled() { return enabled_; }
 
+#if defined(OS_ANDROID)
+  static void InitATrace();
+  static bool IsATraceEnabled();
+#endif
+
   // Enabled state listeners give a callback when tracing is enabled or
   // disabled. This can be used to tie into other library's tracing systems
   // on-demand.
   class EnabledStateChangedObserver {
    public:
     // Called just before the tracing system becomes
     // enabled. TraceLog::IsEnabled will return false at this point and trace
     // macros and methods called within the observer will deadlock.
     virtual void OnTraceLogWillEnable() { }
 
@@ skipping 110 matching lines @@
    private:
     TraceLog* trace_log_;
     NotificationCallback callback_copy_;
     int notification_;
   };
 
   TraceLog();
   ~TraceLog();
   const unsigned char* GetCategoryEnabledInternal(const char* name);
   void AddThreadNameMetadataEvents();
+
+#if defined(OS_ANDROID)
+  void SendToATrace(char phase,
+                    const char* category,
+                    const char* name,
+                    int num_args,
+                    const char** arg_names,
+                    const unsigned char* arg_types,
+                    const unsigned long long* arg_values);
   void AddClockSyncMetadataEvents();
+#endif
 
   // TODO(nduca): switch to per-thread trace buffers to reduce thread
   // synchronization.
   // This lock protects TraceLog member accesses from arbitrary threads.
   Lock lock_;
   bool enabled_;
   NotificationCallback notification_callback_;
   std::vector<TraceEvent> logged_events_;
   std::vector<std::string> included_categories_;
   std::vector<std::string> excluded_categories_;
@@ skipping 11 matching lines @@
   const unsigned char* watch_category_;
   std::string watch_event_name_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_