FBTF: Monster ctor patch after changing heuristics in clang plugin.

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
@@ skipping 40 matching lines @@
 #ifndef REMOTING_BASE_TRACER_H_
 #define REMOTING_BASE_TRACER_H_
 
 #include <string>
 
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/singleton.h"
 #include "base/task.h"
 #include "base/scoped_ptr.h"
-#include "base/thread_local.h"
 #include "remoting/base/protocol/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
@@ skipping 13 matching lines @@
 
   Lock lock_;
   scoped_ptr<TraceBuffer> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Tracer);
 };
 
 class TraceContext {
  public:
   // Get the current tracer.
-  static Tracer* tracer() {
-    return Get()->GetTracerInternal();
-  }
+  static Tracer* tracer();
 
-  static void PushTracer(Tracer* tracer) {
-    Get()->PushTracerInternal(tracer);
-  }
+  static void PushTracer(Tracer* tracer);
 
-  static void PopTracer() {
-    Get()->PopTracerInternal();
-  }
+  static void PopTracer();
 
-  static TraceContext* Get() {
-    TraceContext* context =
-        Singleton<base::ThreadLocalPointer<TraceContext> >::get()->Get();
-    if (context == NULL) {
-      context = new TraceContext();
-      context->PushTracerInternal(new Tracer("default", 0.0));
-      Singleton<base::ThreadLocalPointer<TraceContext> >::get()->Set(context);
-    }
-    return context;
-  }
+  static TraceContext* Get();
 
  private:
-  TraceContext() {
-  }
+  TraceContext();
 
-  ~TraceContext() {}
+  ~TraceContext();
 
-  void PushTracerInternal(Tracer* tracer) { tracers_.push_back(tracer); }
+  void PushTracerInternal(Tracer* tracer);
 
-  void PopTracerInternal() { tracers_.pop_back(); }
+  void PopTracerInternal();
 
-  Tracer* GetTracerInternal() { return tracers_.back(); }
+  Tracer* GetTracerInternal();
 
   std::vector<scoped_refptr<Tracer> > tracers_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceContext);
 };
 
 // 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
@@ skipping 121 matching lines @@
                                                                   e, f, g));
 }
 
 #else
 #  define NewTracedMethod NewRunnableMethod
 #endif
 
 }  // namespace remoting
 
 #endif  // REMOTING_BASE_TRACER_H_