Remove all the experimental Traced Task code from remoting.

This code is obsolete and never fully functioned anyways. Deleting.

BUG=57373,65680,73744
TEST=valgrind


Review URL: http://codereview.chromium.org/7780019

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@100788 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 0 insertions, 444 deletions

diff --git a/remoting/base/tracer.cc b/remoting/base/tracer.cc
deleted file mode 100644
index 677db3a..0000000
--- a/remoting/base/tracer.cc
+++ /dev/null
@@ -1,192 +0,0 @@
-// 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 "remoting/base/tracer.h"
-
-#include <list>
-
-#include "base/basictypes.h"
-#include "base/lazy_instance.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop.h"
-#include "base/rand_util.h"
-#include "base/stl_util.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/threading/thread.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local.h"
-#include "base/time.h"
-
-namespace remoting {
-
-namespace {
-
-class OutputLogger {
- public:
-  OutputLogger()
-      : thread_("logging_thread"),
-        stopped_(false),
-        wake_(&lock_) {
-    thread_.Start();
-    thread_.message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(this, &OutputLogger::PrintLogs));
-  }
-
-  void OutputTrace(TraceBuffer* buffer) {
-    scoped_ptr<TraceBuffer> buffer_ref_(buffer);
-    base::AutoLock l(lock_);
-
-    // Drop messages if we're overwhelming the logger.
-    if (buffers_.size() < 10) {
-      buffers_.push_front(buffer_ref_.release());
-      wake_.Signal();
-    } else {
-      // TODO(ajwong): Remove this cause it just overwhelms the logging more.
-      LOG(WARNING) << "Message dropped.";
-    }
-  }
-
-  void LogOneTrace(TraceBuffer* buffer) {
-    VLOG(1) << "Trace: " << buffer->name();
-    base::Time last_timestamp;
-    for (int i = 0; i < buffer->record_size(); ++i) {
-      const TraceRecord& record = buffer->record(i);
-      base::Time timestamp = base::Time::FromInternalValue(record.timestamp());
-      if (i == 0) {
-        VLOG(1) << "  TS: " << record.timestamp()
-                << " msg: " << record.annotation();
-      } else {
-        base::TimeDelta delta = timestamp - last_timestamp;
-        VLOG(1) << "  TS: " << record.timestamp()
-                << " msg: " << record.annotation()
-                << " [ " << delta.InMilliseconds() << "ms ]";
-      }
-      last_timestamp = timestamp;
-    }
-  }
-
-  void PrintLogs() {
-    while(!stopped_) {
-      TraceBuffer* buffer = NULL;
-      {
-        base::AutoLock l(lock_);
-        if (buffers_.empty()) {
-          wake_.Wait();
-        }
-        // Check again since we might have woken for a stop signal.
-        if (!buffers_.empty()) {
-          buffer = buffers_.back();
-          buffers_.pop_back();
-        }
-      }
-
-      if (buffer) {
-        LogOneTrace(buffer);
-        delete buffer;
-      }
-    }
-  }
-
- private:
-  friend struct base::DefaultLazyInstanceTraits<OutputLogger>;
-
-  ~OutputLogger() {
-    {
-      base::AutoLock l(lock_);
-      stopped_ = true;
-      wake_.Signal();
-    }
-
-    thread_.Stop();
-    STLDeleteElements(&buffers_);
-  }
-
-  base::Lock lock_;
-  base::Thread thread_;
-  bool stopped_;
-  base::ConditionVariable wake_;
-  std::list<TraceBuffer*> buffers_;
-};
-
-static base::LazyInstance<OutputLogger> g_output_logger(
-    base::LINKER_INITIALIZED);
-static base::LazyInstance<base::ThreadLocalPointer<TraceContext> >
-    g_thread_local_trace_context(base::LINKER_INITIALIZED);
-
-}  // namespace
-
-Tracer::Tracer(const std::string& name, double sample_percent) {
-  if (sample_percent > base::RandDouble()) {
-    buffer_.reset(new TraceBuffer());
-    buffer_->set_name(name);
-  }
-}
-
-void Tracer::PrintString(const std::string& s) {
-  base::AutoLock l(lock_);
-  if (!buffer_.get()) {
-    return;
-  }
-
-  TraceRecord* record = buffer_->add_record();
-  record->set_annotation(s);
-  record->set_timestamp(base::Time::Now().ToInternalValue());
-
-  // Take the pointer for the current messageloop as identifying for the
-  // current thread.
-  record->set_thread_id(static_cast<uint64>(base::PlatformThread::CurrentId()));
-}
-
-Tracer::~Tracer() {
-  base::AutoLock l(lock_);
-
-  if (buffer_.get()) {
-    g_output_logger.Get().OutputTrace(buffer_.release());
-  }
-}
-
-// static
-Tracer* TraceContext::tracer() {
-  return Get()->GetTracerInternal();
-}
-
-// static
-void TraceContext::PushTracer(Tracer* tracer) {
-  Get()->PushTracerInternal(tracer);
-}
-
-// static
-void TraceContext::PopTracer() {
-  Get()->PopTracerInternal();
-}
-
-// static
-TraceContext* TraceContext::Get() {
-  TraceContext* context =
-      g_thread_local_trace_context.Get().Get();
-  if (context == NULL) {
-    context = new TraceContext();
-    context->PushTracerInternal(new Tracer("default", 0.0));
-    g_thread_local_trace_context.Get().Set(context);
-  }
-  return context;
-}
-
-TraceContext::TraceContext() {}
-
-TraceContext::~TraceContext() {}
-
-void TraceContext::PushTracerInternal(Tracer* tracer) {
-  tracers_.push_back(make_scoped_refptr(tracer));
-}
-
-void TraceContext::PopTracerInternal() { tracers_.pop_back(); }
-
-Tracer* TraceContext::GetTracerInternal() { return tracers_.back(); }
-
-
-}  // namespace remoting
-
-DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::OutputLogger);
diff --git a/remoting/base/tracer.h b/remoting/base/tracer.h
deleted file mode 100644
index 0fcbdfa..0000000
--- a/remoting/base/tracer.h
+++ /dev/null
@@ -1,252 +0,0 @@
-// 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.
-
-// 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::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::tracer()->PrintString("Frame outputed");
-//   ...
-// }
-//
-// void Decoder::DecodeDone() {
-//   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_
-
-#include <string>
-
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/singleton.h"
-#include "base/synchronization/lock.h"
-#include "base/task.h"
-#include "remoting/proto/trace.pb.h"
-
-namespace remoting {
-
-class Tracer : public base::RefCountedThreadSafe<Tracer> {
- public:
-  // The |name| is just a label for the given tracer. It is recorder into the
-  // trace buffer and printed at the end. Use it specify one logical flow such
-  // as "Host Update Request".  The sample_percent is to allow for gathering a
-  // random sampling of the traces. This allows the tracer to be used in a
-  // high-frequency code path without spamming the log, or putting undo load on
-  // the system.  Use 0.0 to disable the tracer completely, and 1.0 to log
-  // everything.
-  Tracer(const std::string& name, double sample_percent);
-
-  // TODO(ajwong): Consider using an ostream interface similar to DLOG.
-  void PrintString(const std::string& s);
-
-  void OutputTrace();
-
- private:
-  friend class base::RefCountedThreadSafe<Tracer>;
-  virtual ~Tracer();
-
-  base::Lock lock_;
-  scoped_ptr<TraceBuffer> buffer_;
-
-  DISALLOW_COPY_AND_ASSIGN(Tracer);
-};
-
-class TraceContext {
- public:
-  // Get the current tracer.
-  static Tracer* tracer();
-
-  static void PushTracer(Tracer* tracer);
-
-  static void PopTracer();
-
-  static TraceContext* Get();
-
- private:
-  TraceContext();
-
-  ~TraceContext();
-
-  void PushTracerInternal(Tracer* tracer);
-
-  void PopTracerInternal();
-
-  Tracer* GetTracerInternal();
-
-  std::vector<scoped_refptr<Tracer> > tracers_;
-
-  DISALLOW_COPY_AND_ASSIGN(TraceContext);
-};
-
-// Used to create a new tracer that NewRunnableMethod can propagate 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
-// original NewRunnableMethod and NewCallback systems.
-#if defined(USE_TRACE)
-
-template <class T, class Method, class Params>
-class TracedMethod : public RunnableMethod<T, Method, Params> {
- public:
-  TracedMethod(T* obj, Method meth, const Params& params)
-      : RunnableMethod<T, Method, Params>(obj, meth, params),
-        tracer_(TraceContext::tracer()) {
-  }
-
-  virtual ~TracedMethod() {
-  }
-
-  virtual void Run() {
-    TraceContext::PushTracer(tracer_);
-    RunnableMethod<T, Method, Params>::Run();
-    TraceContext::PopTracer();
-  }
-
- private:
-  scoped_refptr<Tracer> tracer_;
-};
-
-template <class T, class Method>
-inline CancelableTask* NewTracedMethod(T* object, Method method) {
-  return new TracedMethod<T, Method, Tuple0>(object, method, MakeTuple());
-}
-
-template <class T, class Method, class A>
-inline CancelableTask* NewTracedMethod(T* object, Method method, const A& a) {
-  return new TracedMethod<T, Method, Tuple1<A> >(object,
-                                                 method,
-                                                 MakeTuple(a));
-}
-
-template <class T, class Method, class A, class B>
-inline CancelableTask* NewTracedMethod(T* object, Method method,
-                                       const A& a, const B& b) {
-  return new TracedMethod<T, Method, Tuple2<A, B> >(object, method,
-                                                    MakeTuple(a, b));
-}
-
-template <class T, class Method, class A, class B, class C>
-inline CancelableTask* NewTracedMethod(T* object, Method method,
-                                       const A& a, const B& b, const C& c) {
-  return new TracedMethod<T, Method, Tuple3<A, B, C> >(object, method,
-                                                       MakeTuple(a, b, c));
-}
-
-template <class T, class Method, class A, class B, class C, class D>
-inline CancelableTask* NewTracedMethod(T* object, Method method,
-                                       const A& a, const B& b,
-                                       const C& c, const D& d) {
-  return new TracedMethod<T, Method, Tuple4<A, B, C, D> >(object, method,
-                                                          MakeTuple(a, b,
-                                                                    c, d));
-}
-
-template <class T, class Method, class A, class B, class C, class D, class E>
-inline CancelableTask* NewTracedMethod(T* object, Method method,
-                                       const A& a, const B& b,
-                                       const C& c, const D& d, const E& e) {
-  return new TracedMethod<T,
-  Method,
-  Tuple5<A, B, C, D, E> >(object,
-                          method,
-                          MakeTuple(a, b, c, d, e));
-}
-
-template <class T, class Method, class A, class B, class C, class D, class E,
-          class F>
-inline CancelableTask* NewTracedMethod(T* object, Method method,
-                                       const A& a, const B& b,
-                                       const C& c, const D& d,
-                                       const E& e, const F& f) {
-  return new TracedMethod<T,
-                          Method,
-                          Tuple6<A, B, C, D, E, F> >(object,
-                                                     method,
-                                                     MakeTuple(a, b, c, d, e,
-                                                               f));
-}
-
-template <class T, class Method, class A, class B, class C, class D, class E,
-          class F, class G>
-inline CancelableTask* NewTracedMethod(T* object, Method method,
-                                       const A& a, const B& b,
-                                       const C& c, const D& d, const E& e,
-                                       const F& f, const G& g) {
-  return new TracedMethod<T,
-                          Method,
-                          Tuple7<A, B, C, D, E, F, G> >(object,
-                                                        method,
-                                                        MakeTuple(a, b, c, d,
-                                                                  e, f, g));
-}
-
-#else
-#  define NewTracedMethod NewRunnableMethod
-#endif
-
-}  // namespace remoting
-
-#endif  // REMOTING_BASE_TRACER_H_