Move decoder into separate thread, clean up API layering, and redo update protocl

remoting/base/tracer.h

 // Copyright (c) 2010 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.
 
 // Tracer objects uresed to record an annotated timeline of events for use in
 // gathering performance data.  It wraps a TraceBuffer which is the raw data
 // for a trace. Tracer is threadsafe.
 //
 // TraceContext is a singleton that is used to give information for the current
 // trace. Clients should query TraceContext to find the current tracer and then
 // use that for logging annotations. TraceContext is threadsafe.
 //
 // ScopedTracer pushes a new Tracer on the TraceContext.  It's scoped in that
 // this tracer is popped off the context when ScopedTracer goes out of scope.
 // However, if a call to NewTracedMethod is made while the ScopedTracer is in
 // scope, then a reference to the Tracer will be kept in the resulting Task and
 // repushed onto the stack when the Task is run.  Conceptually, this simulates
 // the current context being continued when the Task is invoked.  You usually
 // will want to declare a ScopedTracer at the start of a logical flow of
 // operations.
 //
 // Example Usage:
 //
 // void Decoder::StartDecode() {
 //   ScopedTracer tracer("decode_start");
 //
-//   TraceContext::current()->PrintString("Decode starting");
+//   TraceContext::tracer()->PrintString("Decode starting");
 //
 //   // DoDecode takes 2 parameters. The first is a callback invoked for each
 //   // finished frame of output.  The second is invoked when the task is done.
 //   DoDecode(NewTracedMethod(this, &Decoder::OnFrameOutput),
 //            NewTracedMethod(this, &Decoder::DecodeDone));
 //   }
 // }
 //
 // void Decoder::OnFrameOutput() {
-//   TraceContext::current()->PrintString("Frame outputed");
+//   TraceContext::tracer()->PrintString("Frame outputed");
 //   ...
 // }
 //
 // void Decoder::DecodeDone() {
-//   TraceContext::current()->PrintString("decode done");
+//   TraceContext::tracer()->PrintString("decode done");
 //   ...
 // }
 //
 // For each call of StartDecode(), the related calls to OnFrameOutput() and
 // DecodeDone() will be annotated to the Tracer created by the ScopedTracer
 // declaration allowing for creating of timing information over the related
 // asynchronous Task invocations.
 
 #ifndef REMOTING_BASE_TRACER_H_
 #define REMOTING_BASE_TRACER_H_
@@ skipping 31 matching lines @@
   virtual ~Tracer();
 
   Lock lock_;
   scoped_ptr<TraceBuffer> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Tracer);
 };
 
 class TraceContext {
  public:
-  // Set the current tracer.
+  // Get the current tracer.
   static Tracer* tracer() {
     return Get()->GetTracerInternal();
   }
 
   static void PushTracer(Tracer* tracer) {
     Get()->PushTracerInternal(tracer);
   }
 
   static void PopTracer() {
     Get()->PopTracerInternal();
@@ skipping 30 matching lines @@
 // Used to create a new tracer that NewRunnableMethod can propogate from.
 //
 // Declare this at the logical start of a "trace."  Calls to NewTracedMethod
 // that are done with the ScopedTracer object is alive will take a reference
 // to this tracer.  When such a method is invoked, it will push the trace back
 // onto the top of the TraceContext stack.  The result is that all asynchronous
 // tasks that are part of one logical flow will share the same trace.
 class ScopedTracer {
  public:
   ScopedTracer(const std::string& name) {
+#if defined(USE_TRACE)
     scoped_refptr<Tracer> tracer = new Tracer(name, 1.00);
     TraceContext::PushTracer(tracer);
+#endif
   }
 
   ~ScopedTracer() {
+#if defined(USE_TRACE)
     TraceContext::PopTracer();
+#endif
   }
 };
 
 // This is experimental code.  I'm creating a set of analogues to
 // the NewRunnableMethod functions called NewTracedMethod, which should be
 // API equivalent to the former.  In fact, they must be enabled by setting
 // USE_TRACE 1 for now.
 //
 // The idea is to add hooks for performance traces into the Task/Callback
 // mechanisms.  If it works well enough, will think about generalizing into the
@@ skipping 95 matching lines @@
                                                                   e, f, g));
 }
 
 #else
 #  define NewTracedMethod NewRunnableMethod
 #endif
 
 }  // namespace remoting
 
 #endif  // REMOTING_BASE_TRACER_H_