diff --git a/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_trace_marker.txt b/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_trace_marker.txt
new file mode 100644
index 0000000..7dfb78e
--- /dev/null
+++ b/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_trace_marker.txt
@@ -0,0 +1,63 @@
+Name
+
+    CHROMIUM_trace_marker
+
+Name Strings
+
+    GL_CHROMIUM_trace_marker
+
+Version
+
+    Last Modifed Date: December 17, 2014
+
+Dependencies
+
+    OpenGL ES 2.0 is required.
+
+Overview
+
+    This extension lets you mark chromium style GPU traces. Each trace can
+    specify both a category name and a trace name which will be associated
+    with the trace.
+
+    Each trace's beginning is marked by TraceBeginCHROMIUM and the end can
+    optionally be marked by TraceEndCHROMIUM. If the trace's end is not marked,
+    the trace will automatically end when the graphics context is destroyed.
+
+    Multiple traces can happen simultaneously, however traces act as a stack
+    and must be fully contained within one another. Therefore, you cannot
+    have overlapping traces.
+
+    Once a trace has been recorded, it is up to the application to decide
+    how the traces should be displayed.
+
+New Tokens
+
+    None
+
+New Procedures and Functions
+
+    void TraceBeginCHROMIUM(const char* category_name, const char* trace_name)
+
+    Marks the beginning of when a GPU trace should begin. Once the trace begins
+    it lasts until the graphics context is destroyed or when TraceEndCHROMIUM
+    is called.
+
+
+    void TraceEndCHROMIUM()
+
+    Marks the last trace to end, this will signal the application to stop
+    tracing the previous trace.
+
+Errors
+
+    None.
+
+New State
+
+    None.
+
+Revision History
+
+    12/17/2014    Documented the extension
+
diff --git a/gpu/blink/webgraphicscontext3d_impl.cc b/gpu/blink/webgraphicscontext3d_impl.cc
index 26a366c..2681abc 100644
--- a/gpu/blink/webgraphicscontext3d_impl.cc
+++ b/gpu/blink/webgraphicscontext3d_impl.cc
@@ -885,6 +885,11 @@
                  WGC3Dint,
                  WGC3Denum,
                  WGC3Denum);
+DELEGATE_TO_GL_2(traceBeginCHROMIUM,
+                 TraceBeginCHROMIUM,
+                 const WGC3Dchar*,
+                 const WGC3Dchar*);
+DELEGATE_TO_GL(traceEndCHROMIUM, TraceEndCHROMIUM);
 
 void WebGraphicsContext3DImpl::insertEventMarkerEXT(
     const WGC3Dchar* marker) {
diff --git a/gpu/blink/webgraphicscontext3d_impl.h b/gpu/blink/webgraphicscontext3d_impl.h
index 41a6d89..11a3dc5 100644
--- a/gpu/blink/webgraphicscontext3d_impl.h
+++ b/gpu/blink/webgraphicscontext3d_impl.h
@@ -493,6 +493,9 @@
   virtual void uniformValuebufferCHROMIUM(WGC3Dint location,
                                           WGC3Denum target,
                                           WGC3Denum subscription);
+  virtual void traceBeginCHROMIUM(const WGC3Dchar* category_name,
+                                  const WGC3Dchar* trace_name);
+  virtual void traceEndCHROMIUM();
 
   virtual void insertEventMarkerEXT(const WGC3Dchar* marker);
   virtual void pushGroupMarkerEXT(const WGC3Dchar* marker);
diff --git a/gpu/command_buffer/client/context_support.h b/gpu/command_buffer/client/context_support.h
index 2678ba9..6c5b23f 100644
--- a/gpu/command_buffer/client/context_support.h
+++ b/gpu/command_buffer/client/context_support.h
@@ -6,8 +6,8 @@
 #define GPU_COMMAND_BUFFER_CLIENT_CONTEXT_SUPPORT_H_
 
 #include "base/callback.h"
+#include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/overlay_transform.h"
-#include "ui/gfx/rect.h"
 
 namespace gpu {
 
diff --git a/gpu/command_buffer/client/gl_in_process_context.cc b/gpu/command_buffer/client/gl_in_process_context.cc
index 015a2a7..0f15f1d 100644
--- a/gpu/command_buffer/client/gl_in_process_context.cc
+++ b/gpu/command_buffer/client/gl_in_process_context.cc
@@ -26,7 +26,7 @@
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
-#include "ui/gfx/size.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_image.h"
 
 #if defined(OS_ANDROID)
diff --git a/gpu/command_buffer/service/feature_info.cc b/gpu/command_buffer/service/feature_info.cc
index a225478..5706086 100644
--- a/gpu/command_buffer/service/feature_info.cc
+++ b/gpu/command_buffer/service/feature_info.cc
@@ -289,6 +289,7 @@
   AddExtensionString("GL_CHROMIUM_resource_safe");
   AddExtensionString("GL_CHROMIUM_strict_attribs");
   AddExtensionString("GL_CHROMIUM_texture_mailbox");
+  AddExtensionString("GL_CHROMIUM_trace_marker");
   AddExtensionString("GL_EXT_debug_marker");
 
   if (feature_flags_.enable_subscribe_uniform) {
diff --git a/gpu/command_buffer/service/feature_info_unittest.cc b/gpu/command_buffer/service/feature_info_unittest.cc
index f5440e0..e81dad1 100644
--- a/gpu/command_buffer/service/feature_info_unittest.cc
+++ b/gpu/command_buffer/service/feature_info_unittest.cc
@@ -235,6 +235,7 @@
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_strict_attribs"));
   EXPECT_THAT(info_->extensions(),
               HasSubstr("GL_ANGLE_translated_shader_source"));
+  EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_trace_marker"));
 
   // Check a couple of random extensions that should not be there.
   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_npot")));
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 9ad567a..7f9166e 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -1878,7 +1878,6 @@
   scoped_ptr<GPUStateTracer> gpu_state_tracer_;
   const unsigned char* cb_command_trace_category_;
   const unsigned char* gpu_decoder_category_;
-  const unsigned char* gpu_group_marker_category_;
   int gpu_trace_level_;
   bool gpu_trace_commands_;
   bool gpu_debug_commands_;
@@ -2396,8 +2395,6 @@
           TRACE_DISABLED_BY_DEFAULT("cb_command"))),
       gpu_decoder_category_(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
           TRACE_DISABLED_BY_DEFAULT("gpu_decoder"))),
-      gpu_group_marker_category_(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
-          TRACE_DISABLED_BY_DEFAULT("gpu_group_marker"))),
       gpu_trace_level_(2),
       gpu_trace_commands_(false),
       gpu_debug_commands_(false),
@@ -11006,17 +11003,13 @@
   }
   std::string name = length ? std::string(marker, length) : std::string(marker);
   debug_marker_manager_.PushGroup(name);
-  if (*gpu_group_marker_category_) {
-    gpu_tracer_->Begin(TRACE_DISABLED_BY_DEFAULT("gpu_group_marker"), name,
-                       kTraceGroupMarker);
-  }
+  gpu_tracer_->Begin(TRACE_DISABLED_BY_DEFAULT("gpu_group_marker"), name,
+                     kTraceGroupMarker);
 }
 
 void GLES2DecoderImpl::DoPopGroupMarkerEXT(void) {
   debug_marker_manager_.PopGroup();
-  if (*gpu_group_marker_category_) {
-    gpu_tracer_->End(kTraceGroupMarker);
-  }
+  gpu_tracer_->End(kTraceGroupMarker);
 }
 
 void GLES2DecoderImpl::DoBindTexImage2DCHROMIUM(
@@ -11124,8 +11117,6 @@
     return error::kInvalidArguments;
   }
 
-  TRACE_EVENT_COPY_ASYNC_BEGIN0(category_name.c_str(), trace_name.c_str(),
-                                this);
   if (!gpu_tracer_->Begin(category_name, trace_name, kTraceCHROMIUM)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
@@ -11136,16 +11127,11 @@
 }
 
 void GLES2DecoderImpl::DoTraceEndCHROMIUM() {
-  if (gpu_tracer_->CurrentCategory().empty() ||
-      gpu_tracer_->CurrentName().empty()) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glTraceEndCHROMIUM", "no trace begin found");
+  if (!gpu_tracer_->End(kTraceCHROMIUM)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+                       "glTraceEndCHROMIUM", "no trace begin found");
     return;
   }
-  TRACE_EVENT_COPY_ASYNC_END0(gpu_tracer_->CurrentCategory().c_str(),
-                              gpu_tracer_->CurrentName().c_str(), this);
-  gpu_tracer_->End(kTraceCHROMIUM);
 }
 
 void GLES2DecoderImpl::DoDrawBuffersEXT(
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.h b/gpu/command_buffer/service/gles2_cmd_decoder.h
index 670ce75..0092a9a 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.h
@@ -16,7 +16,7 @@
 #include "gpu/command_buffer/common/capabilities.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/logger.h"
-#include "ui/gfx/size.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 
 namespace gfx {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
index 4428a40..35ff4c1 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
@@ -9,11 +9,11 @@
 
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
-#include "base/callback_forward.h"
 #include "testing/gmock/include/gmock/gmock.h"
-#include "ui/gfx/size.h"
+#include "ui/gfx/geometry/size.h"
 
 namespace gfx {
 class GLContext;
diff --git a/gpu/command_buffer/service/gpu_tracer.cc b/gpu/command_buffer/service/gpu_tracer.cc
index d7cd1b8..2853e96c 100644
--- a/gpu/command_buffer/service/gpu_tracer.cc
+++ b/gpu/command_buffer/service/gpu_tracer.cc
@@ -18,6 +18,16 @@
 static const unsigned int kProcessInterval = 16;
 static TraceOutputter* g_outputter_thread = NULL;
 
+CPUTime::CPUTime() {
+}
+
+int64 CPUTime::GetCurrentTime() {
+  return base::TimeTicks::NowFromSystemTraceTime().ToInternalValue();
+}
+
+CPUTime::~CPUTime() {
+}
+
 TraceMarker::TraceMarker(const std::string& category, const std::string& name)
     : category_(category),
       name_(name),
@@ -42,24 +52,47 @@
 
 TraceOutputter::~TraceOutputter() { g_outputter_thread = NULL; }
 
-void TraceOutputter::Trace(const std::string& category,
-                           const std::string& name,
-                           int64 start_time,
-                           int64 end_time) {
-  TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category.c_str(),
-                                                    name.c_str(),
-                                                    local_trace_id_,
-                                                    named_thread_.thread_id(),
-                                                    start_time);
-  TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0(category.c_str(),
-                                                  name.c_str(),
-                                                  local_trace_id_,
-                                                  named_thread_.thread_id(),
-                                                  end_time);
+void TraceOutputter::TraceDevice(const std::string& category,
+                                 const std::string& name,
+                                 int64 start_time,
+                                 int64 end_time) {
+  TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP1(
+      TRACE_DISABLED_BY_DEFAULT("gpu.device"),
+      name.c_str(),
+      local_trace_id_,
+      named_thread_.thread_id(),
+      start_time,
+      "gl_category",
+      category.c_str());
+  TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP1(
+      TRACE_DISABLED_BY_DEFAULT("gpu.device"),
+      name.c_str(),
+      local_trace_id_,
+      named_thread_.thread_id(),
+      end_time,
+      "gl_category",
+      category.c_str());
   ++local_trace_id_;
 }
 
+void TraceOutputter::TraceServiceBegin(const std::string& category,
+                                       const std::string& name,
+                                       void* id) {
+  TRACE_EVENT_COPY_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("gpu.service"),
+                                  name.c_str(), this,
+                                  "gl_category", category.c_str());
+}
+
+void TraceOutputter::TraceServiceEnd(const std::string& category,
+                                     const std::string& name,
+                                     void* id) {
+  TRACE_EVENT_COPY_ASYNC_END1(TRACE_DISABLED_BY_DEFAULT("gpu.service"),
+                                name.c_str(), this,
+                                "gl_category", category.c_str());
+}
+
 GPUTrace::GPUTrace(scoped_refptr<Outputter> outputter,
+                   scoped_refptr<CPUTime> cpu_time,
                    const std::string& category,
                    const std::string& name,
                    int64 offset,
@@ -67,6 +100,7 @@
     : category_(category),
       name_(name),
       outputter_(outputter),
+      cpu_time_(cpu_time),
       offset_(offset),
       start_time_(0),
       end_time_(0),
@@ -98,7 +132,7 @@
 
 void GPUTrace::Start(bool trace_service) {
   if (trace_service) {
-    TRACE_EVENT_COPY_ASYNC_BEGIN0(category().c_str(), name().c_str(), this);
+    outputter_->TraceServiceBegin(category_, name_, this);
   }
 
   switch (tracer_type_) {
@@ -115,7 +149,7 @@
       if (offset_ == 0) {
         GLint64 gl_now = 0;
         glGetInteger64v(GL_TIMESTAMP, &gl_now);
-        offset_ = base::TimeTicks::NowFromSystemTraceTime().ToInternalValue() -
+        offset_ = cpu_time_->GetCurrentTime() -
                   gl_now / base::Time::kNanosecondsPerMicrosecond;
       }
       // Intentionally fall through to kTracerTypeARBTimer case.xs
@@ -140,7 +174,7 @@
   }
 
   if (tracing_service) {
-    TRACE_EVENT_COPY_ASYNC_END0(category().c_str(), name().c_str(), this);
+    outputter_->TraceServiceEnd(category_, name_, this);
   }
 }
 
@@ -175,7 +209,7 @@
   start_time_ = (begin_stamp / base::Time::kNanosecondsPerMicrosecond) +
                 offset_;
   end_time_ = (end_stamp / base::Time::kNanosecondsPerMicrosecond) + offset_;
-  outputter_->Trace(category(), name(), start_time_, end_time_);
+  outputter_->TraceDevice(category_, name_, start_time_, end_time_);
 }
 
 GPUTracer::GPUTracer(gles2::GLES2Decoder* decoder)
@@ -185,18 +219,10 @@
           TRACE_DISABLED_BY_DEFAULT("gpu.device"))),
       decoder_(decoder),
       timer_offset_(0),
-      last_tracer_source_(kTraceGroupInvalid),
       tracer_type_(kTracerTypeInvalid),
       gpu_timing_synced_(false),
       gpu_executing_(false),
       process_posted_(false) {
-  if (gfx::g_driver_gl.ext.b_GL_EXT_disjoint_timer_query) {
-    tracer_type_ = kTracerTypeDisjointTimer;
-    outputter_ = TraceOutputter::Create("GL_EXT_disjoint_timer_query");
-  } else if (gfx::g_driver_gl.ext.b_GL_ARB_timer_query) {
-    tracer_type_ = kTracerTypeARBTimer;
-    outputter_ = TraceOutputter::Create("GL_ARB_timer_query");
-  }
 }
 
 GPUTracer::~GPUTracer() {
@@ -206,6 +232,28 @@
   if (gpu_executing_)
     return false;
 
+  if (outputter_ == NULL) {
+    tracer_type_ = DetermineTracerType();
+    const char* tracer_type_name = "Unknown";
+    switch (tracer_type_) {
+      case kTracerTypeDisjointTimer:
+        tracer_type_name = "GL_EXT_disjoint_timer_query";
+        break;
+      case kTracerTypeARBTimer:
+        tracer_type_name = "GL_ARB_timer_query";
+        break;
+
+      default:
+        break;
+    }
+
+    outputter_ = CreateOutputter(tracer_type_name);
+  }
+
+  if (cpu_time_ == NULL) {
+    cpu_time_ = CreateCPUTime();
+  }
+
   CalculateTimerOffset();
   gpu_executing_ = true;
 
@@ -237,10 +285,12 @@
   if (IsTracing()) {
     for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
       for (size_t i = 0; i < markers_[n].size(); i++) {
-        if (markers_[n][i].trace_.get()) {
-          markers_[n][i].trace_->End(*gpu_trace_srv_category != 0);
-          if (markers_[n][i].trace_->IsEnabled())
-            traces_.push_back(markers_[n][i].trace_);
+        TraceMarker& marker = markers_[n][i];
+        if (marker.trace_.get()) {
+          marker.trace_->End(*gpu_trace_srv_category != 0);
+          if (marker.trace_->IsEnabled())
+            traces_.push_back(marker.trace_);
+
           markers_[n][i].trace_ = 0;
         }
       }
@@ -263,7 +313,6 @@
   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
 
   // Push new marker from given 'source'
-  last_tracer_source_ = source;
   markers_[source].push_back(TraceMarker(category, name));
 
   // Create trace
@@ -304,20 +353,20 @@
   return (*gpu_trace_srv_category != 0) || (*gpu_trace_dev_category != 0);
 }
 
-const std::string& GPUTracer::CurrentCategory() const {
-  if (last_tracer_source_ >= 0 &&
-      last_tracer_source_ < NUM_TRACER_SOURCES &&
-      !markers_[last_tracer_source_].empty()) {
-    return markers_[last_tracer_source_].back().category_;
+const std::string& GPUTracer::CurrentCategory(GpuTracerSource source) const {
+  if (source >= 0 &&
+      source < NUM_TRACER_SOURCES &&
+      !markers_[source].empty()) {
+    return markers_[source].back().category_;
   }
   return base::EmptyString();
 }
 
-const std::string& GPUTracer::CurrentName() const {
-  if (last_tracer_source_ >= 0 &&
-      last_tracer_source_ < NUM_TRACER_SOURCES &&
-      !markers_[last_tracer_source_].empty()) {
-    return markers_[last_tracer_source_].back().name_;
+const std::string& GPUTracer::CurrentName(GpuTracerSource source) const {
+  if (source >= 0 &&
+      source < NUM_TRACER_SOURCES &&
+      !markers_[source].empty()) {
+    return markers_[source].back().name_;
   }
   return base::EmptyString();
 }
@@ -327,7 +376,33 @@
   GpuTracerType tracer_type = *gpu_trace_dev_category ? tracer_type_ :
                                                         kTracerTypeInvalid;
 
-  return new GPUTrace(outputter_, category, name, timer_offset_, tracer_type);
+  return new GPUTrace(outputter_, cpu_time_, category, name,
+                      timer_offset_, tracer_type);
+}
+
+scoped_refptr<Outputter> GPUTracer::CreateOutputter(const std::string& name) {
+  return TraceOutputter::Create(name);
+}
+
+scoped_refptr<CPUTime> GPUTracer::CreateCPUTime() {
+  return new CPUTime();
+}
+
+GpuTracerType GPUTracer::DetermineTracerType() {
+  if (gfx::g_driver_gl.ext.b_GL_EXT_disjoint_timer_query) {
+    return kTracerTypeDisjointTimer;
+  } else if (gfx::g_driver_gl.ext.b_GL_ARB_timer_query) {
+    return kTracerTypeARBTimer;
+  }
+
+  return kTracerTypeInvalid;
+}
+
+void GPUTracer::PostTask() {
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&GPUTracer::Process, base::AsWeakPtr(this)),
+      base::TimeDelta::FromMilliseconds(kProcessInterval));
 }
 
 void GPUTracer::Process() {
@@ -401,10 +476,8 @@
     glGetQueryObjectui64v(query, GL_QUERY_RESULT, &gl_now);
     glDeleteQueriesARB(1, &query);
 
-    base::TimeTicks system_now = base::TimeTicks::NowFromSystemTraceTime();
-
     gl_now /= base::Time::kNanosecondsPerMicrosecond;
-    timer_offset_ = system_now.ToInternalValue() - gl_now;
+    timer_offset_ = cpu_time_->GetCurrentTime() - gl_now;
     gpu_timing_synced_ = true;
   }
 }
@@ -414,10 +487,7 @@
     return;
 
   process_posted_ = true;
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&GPUTracer::Process, base::AsWeakPtr(this)),
-      base::TimeDelta::FromMilliseconds(kProcessInterval));
+  PostTask();
 }
 
 }  // namespace gles2
diff --git a/gpu/command_buffer/service/gpu_tracer.h b/gpu/command_buffer/service/gpu_tracer.h
index 6033220..64f13cc 100644
--- a/gpu/command_buffer/service/gpu_tracer.h
+++ b/gpu/command_buffer/service/gpu_tracer.h
@@ -40,6 +40,21 @@
   kTracerTypeDisjointTimer
 };
 
+// Central accesser to CPU Time
+class GPU_EXPORT CPUTime
+    : public base::RefCounted<CPUTime> {
+ public:
+  CPUTime();
+
+  virtual int64 GetCurrentTime();
+
+ protected:
+  virtual ~CPUTime();
+  friend class base::RefCounted<CPUTime>;
+
+  DISALLOW_COPY_AND_ASSIGN(CPUTime);
+};
+
 // Marker structure for a Trace.
 struct TraceMarker {
   TraceMarker(const std::string& category, const std::string& name);
@@ -51,10 +66,11 @@
 };
 
 // Traces GPU Commands.
-class GPUTracer : public base::SupportsWeakPtr<GPUTracer> {
+class GPU_EXPORT GPUTracer
+    : public base::SupportsWeakPtr<GPUTracer> {
  public:
   explicit GPUTracer(gles2::GLES2Decoder* decoder);
-  ~GPUTracer();
+  virtual ~GPUTracer();
 
   // Scheduled processing in decoder begins.
   bool BeginDecoding();
@@ -69,17 +85,22 @@
   // End the last started trace marker.
   bool End(GpuTracerSource source);
 
-  bool IsTracing();
+  virtual bool IsTracing();
 
   // Retrieve the name of the current open trace.
   // Returns empty string if no current open trace.
-  const std::string& CurrentCategory() const;
-  const std::string& CurrentName() const;
+  const std::string& CurrentCategory(GpuTracerSource source) const;
+  const std::string& CurrentName(GpuTracerSource source) const;
 
- private:
+ protected:
   // Trace Processing.
   scoped_refptr<GPUTrace> CreateTrace(const std::string& category,
                                       const std::string& name);
+  virtual scoped_refptr<Outputter> CreateOutputter(const std::string& name);
+  virtual scoped_refptr<CPUTime> CreateCPUTime();
+  virtual GpuTracerType DetermineTracerType();
+  virtual void PostTask();
+
   void Process();
   void ProcessTraces();
 
@@ -87,6 +108,7 @@
   void IssueProcessTask();
 
   scoped_refptr<Outputter> outputter_;
+  scoped_refptr<CPUTime> cpu_time_;
   std::vector<TraceMarker> markers_[NUM_TRACER_SOURCES];
   std::deque<scoped_refptr<GPUTrace> > traces_;
 
@@ -95,7 +117,6 @@
   gles2::GLES2Decoder* decoder_;
 
   int64 timer_offset_;
-  GpuTracerSource last_tracer_source_;
 
   GpuTracerType tracer_type_;
   bool gpu_timing_synced_;
@@ -107,10 +128,18 @@
 
 class Outputter : public base::RefCounted<Outputter> {
  public:
-  virtual void Trace(const std::string& category,
-                     const std::string& name,
-                     int64 start_time,
-                     int64 end_time) = 0;
+  virtual void TraceDevice(const std::string& category,
+                           const std::string& name,
+                           int64 start_time,
+                           int64 end_time) = 0;
+
+  virtual void TraceServiceBegin(const std::string& category,
+                                 const std::string& name,
+                                 void* id) = 0;
+
+  virtual void TraceServiceEnd(const std::string& category,
+                               const std::string& name,
+                               void* id) = 0;
 
  protected:
   virtual ~Outputter() {}
@@ -120,10 +149,18 @@
 class TraceOutputter : public Outputter {
  public:
   static scoped_refptr<TraceOutputter> Create(const std::string& name);
-  void Trace(const std::string& category,
-             const std::string& name,
-             int64 start_time,
-             int64 end_time) override;
+  void TraceDevice(const std::string& category,
+                   const std::string& name,
+                   int64 start_time,
+                   int64 end_time) override;
+
+  void TraceServiceBegin(const std::string& category,
+                         const std::string& name,
+                         void* id) override;
+
+  void TraceServiceEnd(const std::string& category,
+                       const std::string& name,
+                       void* id) override;
 
  protected:
   friend class base::RefCounted<Outputter>;
@@ -140,6 +177,7 @@
     : public base::RefCounted<GPUTrace> {
  public:
   GPUTrace(scoped_refptr<Outputter> outputter,
+           scoped_refptr<CPUTime> cpu_time,
            const std::string& category,
            const std::string& name,
            int64 offset,
@@ -147,9 +185,6 @@
 
   bool IsEnabled() { return tracer_type_ != kTracerTypeInvalid; }
 
-  const std::string& category() { return category_; }
-  const std::string& name() { return name_; }
-
   void Start(bool trace_service);
   void End(bool tracing_service);
   bool IsAvailable();
@@ -165,6 +200,7 @@
   std::string category_;
   std::string name_;
   scoped_refptr<Outputter> outputter_;
+  scoped_refptr<CPUTime> cpu_time_;
 
   int64 offset_;
   int64 start_time_;
diff --git a/gpu/command_buffer/service/gpu_tracer_unittest.cc b/gpu/command_buffer/service/gpu_tracer_unittest.cc
index ccf4d6d..ae4c970 100644
--- a/gpu/command_buffer/service/gpu_tracer_unittest.cc
+++ b/gpu/command_buffer/service/gpu_tracer_unittest.cc
@@ -5,27 +5,59 @@
 #include <map>
 #include <set>
 
+#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gl/gl_context_stub.h"
 #include "ui/gl/gl_mock.h"
+#include "ui/gl/gl_surface_stub.h"
 
 namespace gpu {
 namespace gles2 {
 
-using ::testing::Return;
-using ::testing::NotNull;
-using ::testing::AtLeast;
-using ::testing::Invoke;
 using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Exactly;
+using ::testing::Invoke;
+using ::testing::NotNull;
+using ::testing::Return;
+
+class FakeCPUTime : public CPUTime {
+ public:
+  FakeCPUTime()
+      : current_cpu_time_(0) {
+  }
+
+  int64 GetCurrentTime() override {
+    return current_cpu_time_;
+  }
+
+  void SetFakeCPUTime(int64 cpu_time) {
+    current_cpu_time_ = cpu_time;
+  }
+
+ protected:
+  ~FakeCPUTime() override {}
+
+  int64 current_cpu_time_;
+};
 
 class MockOutputter : public Outputter {
  public:
   MockOutputter() {}
-  MOCK_METHOD4(Trace,
+  MOCK_METHOD4(TraceDevice,
                void(const std::string& category, const std::string& name,
                     int64 start_time, int64 end_time));
 
+  MOCK_METHOD3(TraceServiceBegin,
+               void(const std::string& category, const std::string& name,
+                    void* id));
+
+  MOCK_METHOD3(TraceServiceEnd,
+               void(const std::string& category, const std::string& name,
+                    void* id));
+
  protected:
   ~MockOutputter() {}
 };
@@ -42,6 +74,7 @@
   }
 
   void SetCurrentGLTime(GLint64 current_time) { current_time_ = current_time; }
+  void SetDisjoint() { disjointed_ = true; }
 
   void GenQueriesARB(GLsizei n, GLuint* ids) {
     for (GLsizei i = 0; i < n; i++) {
@@ -68,7 +101,7 @@
         break;
       }
       default:
-        ASSERT_TRUE(false);
+        FAIL() << "Invalid variable passed to GetQueryObjectiv: " << pname;
     }
   }
 
@@ -79,7 +112,17 @@
         query_timestamp_[id] = current_time_;
         break;
       default:
-        ASSERT_TRUE(false);
+        FAIL() << "Invalid variable passed to QueryCounter: " << target;
+    }
+  }
+
+  void GetInteger64v(GLenum pname, GLint64 * data) {
+    switch (pname) {
+      case GL_TIMESTAMP:
+        *data = current_time_;
+        break;
+      default:
+        FAIL() << "Invalid variable passed to GetInteger64v: " << pname;
     }
   }
 
@@ -90,29 +133,258 @@
         *params = query_timestamp_.find(id)->second;
         break;
       default:
-        ASSERT_TRUE(false);
+        FAIL() << "Invalid variable passed to GetQueryObjectui64v: " << pname;
     }
   }
 
+  void GetIntegerv(GLenum pname, GLint* params) {
+    switch (pname) {
+      case GL_GPU_DISJOINT_EXT:
+        *params = static_cast<GLint>(disjointed_);
+        disjointed_ = false;
+        break;
+      default:
+        FAIL() << "Invalid variable passed to GetIntegerv: " << pname;
+    }
+  }
+
+  void Finish() {
+  }
+
+  GLenum GetError() {
+    return GL_NO_ERROR;
+  }
+
  protected:
+  bool disjointed_;
   GLint64 current_time_;
   GLuint next_query_id_;
   std::set<GLuint> alloced_queries_;
   std::map<GLuint, GLint64> query_timestamp_;
 };
 
-class BaseGpuTracerTest : public GpuServiceTest {
+class GPUTracerTester : public GPUTracer {
  public:
-  BaseGpuTracerTest() {}
+  GPUTracerTester(GpuTracerType tracer_type, gles2::GLES2Decoder* decoder)
+      : GPUTracer(decoder),
+        tracing_enabled_(0),
+        test_tracer_type_(tracer_type) {
+    // Force tracing to be dependent on our mock variable here.
+    gpu_trace_srv_category = &tracing_enabled_;
+    gpu_trace_dev_category = &tracing_enabled_;
+  }
 
-  ///////////////////////////////////////////////////////////////////////////
+  ~GPUTracerTester() override {}
+
+  void SetTracingEnabled(bool enabled) {
+    tracing_enabled_ = enabled ? 1 : 0;
+  }
+
+  void SetOutputter(scoped_refptr<Outputter> outputter) {
+    set_outputter_ = outputter;
+  }
+
+  void SetCPUTime(scoped_refptr<CPUTime> cputime) {
+    set_cputime_ = cputime;
+  }
+
+ protected:
+  scoped_refptr<Outputter> CreateOutputter(const std::string& name) override {
+    if (set_outputter_.get()) {
+      return set_outputter_;
+    }
+    return new MockOutputter();
+  }
+
+  scoped_refptr<CPUTime> CreateCPUTime() override {
+    if (set_cputime_.get()) {
+      return set_cputime_;
+    }
+    return new FakeCPUTime();
+  }
+
+  GpuTracerType DetermineTracerType() override {
+    return test_tracer_type_;
+  }
+
+  void PostTask() override {
+    // Process synchronously.
+    Process();
+  }
+
+  unsigned char tracing_enabled_;
+  GpuTracerType test_tracer_type_;
+
+  scoped_refptr<Outputter> set_outputter_;
+  scoped_refptr<CPUTime> set_cputime_;
+};
+
+class BaseGpuTest : public GpuServiceTest {
+ public:
+  BaseGpuTest(GpuTracerType test_tracer_type)
+      : test_tracer_type_(test_tracer_type) {
+  }
+
+ protected:
+  void SetUp() override {
+    GpuServiceTest::SetUp();
+    gl_fake_queries_.Reset();
+    gl_surface_ = new gfx::GLSurfaceStub();
+    gl_context_ = new gfx::GLContextStub();
+    gl_context_->MakeCurrent(gl_surface_.get());
+
+    outputter_ref_ = new MockOutputter();
+    cpu_time_ref_ = new FakeCPUTime;
+  }
+
+  void TearDown() override {
+    outputter_ref_ = NULL;
+    cpu_time_ref_ = NULL;
+
+    gl_context_->ReleaseCurrent(gl_surface_.get());
+    gl_context_ = NULL;
+    gl_surface_ = NULL;
+
+    gl_.reset();
+    gl_fake_queries_.Reset();
+    GpuServiceTest::TearDown();
+  }
+
+  void ExpectTraceQueryMocks() {
+    if (GetTracerType() != kTracerTypeInvalid) {
+      // Delegate query APIs used by GPUTrace to a GlFakeQueries
+      EXPECT_CALL(*gl_, GenQueriesARB(2, NotNull())).Times(AtLeast(1))
+          .WillRepeatedly(
+              Invoke(&gl_fake_queries_, &GlFakeQueries::GenQueriesARB));
+
+      EXPECT_CALL(*gl_, GetQueryObjectiv(_, GL_QUERY_RESULT_AVAILABLE,
+                                         NotNull()))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::GetQueryObjectiv));
+
+      if (GetTracerType() == kTracerTypeDisjointTimer) {
+        EXPECT_CALL(*gl_, GetInteger64v(GL_TIMESTAMP, _))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::GetInteger64v));
+      }
+
+      EXPECT_CALL(*gl_, QueryCounter(_, GL_TIMESTAMP)).Times(AtLeast(2))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::QueryCounter));
+
+      EXPECT_CALL(*gl_, GetQueryObjectui64v(_, GL_QUERY_RESULT, NotNull()))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_,
+                      &GlFakeQueries::GetQueryObjectui64v));
+
+      EXPECT_CALL(*gl_, DeleteQueriesARB(2, NotNull())).Times(AtLeast(1))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::DeleteQueriesARB));
+    }
+  }
+
+  void ExpectOutputterBeginMocks(MockOutputter* outputter,
+                                 const std::string& category,
+                                 const std::string& name) {
+    EXPECT_CALL(*outputter,
+                TraceServiceBegin(category, name, NotNull()));
+  }
+
+  void ExpectOutputterEndMocks(MockOutputter* outputter,
+                               const std::string& category,
+                               const std::string& name, int64 expect_start_time,
+                               int64 expect_end_time,
+                               bool trace_device) {
+    EXPECT_CALL(*outputter,
+                TraceServiceEnd(category, name, NotNull()));
+
+    if (trace_device) {
+      EXPECT_CALL(*outputter,
+                  TraceDevice(category, name,
+                              expect_start_time, expect_end_time))
+          .Times(Exactly(1));
+    } else {
+      EXPECT_CALL(*outputter, TraceDevice(category, name,
+                                          expect_start_time, expect_end_time))
+          .Times(Exactly(0));
+    }
+  }
+
+  void ExpectOutputterMocks(MockOutputter* outputter,
+                            const std::string& category,
+                            const std::string& name, int64 expect_start_time,
+                            int64 expect_end_time) {
+    ExpectOutputterBeginMocks(outputter, category, name);
+    ExpectOutputterEndMocks(outputter, category, name,
+                            expect_start_time, expect_end_time,
+                            GetTracerType() != kTracerTypeInvalid);
+  }
+
+  void ExpectTracerOffsetQueryMocks() {
+    // Disjoint check should only be called by kTracerTypeDisjointTimer type.
+    if (GetTracerType() == kTracerTypeDisjointTimer) {
+      EXPECT_CALL(*gl_, GetIntegerv(GL_GPU_DISJOINT_EXT, _)).Times(AtLeast(1))
+          .WillRepeatedly(
+              Invoke(&gl_fake_queries_, &GlFakeQueries::GetIntegerv));
+    } else {
+      EXPECT_CALL(*gl_, GetIntegerv(GL_GPU_DISJOINT_EXT, _)).Times(Exactly(0));
+    }
+
+    // Timer offset calculation should only happen for the regular timer.
+    if (GetTracerType() != kTracerTypeARBTimer) {
+      EXPECT_CALL(*gl_, GenQueriesARB(_, NotNull())).Times(Exactly(0));
+      EXPECT_CALL(*gl_, Finish()).Times(Exactly(0));
+      EXPECT_CALL(*gl_, QueryCounter(_, GL_TIMESTAMP)).Times(Exactly(0));
+      EXPECT_CALL(*gl_, GetQueryObjectui64v(_, GL_QUERY_RESULT, NotNull()))
+          .Times(Exactly(0));
+      EXPECT_CALL(*gl_, DeleteQueriesARB(_, NotNull())).Times(Exactly(0));
+    } else {
+      EXPECT_CALL(*gl_, GenQueriesARB(_, NotNull())).Times(AtLeast(1))
+          .WillRepeatedly(
+              Invoke(&gl_fake_queries_, &GlFakeQueries::GenQueriesARB));
+
+      EXPECT_CALL(*gl_, Finish()).Times(AtLeast(2))
+          .WillRepeatedly(
+              Invoke(&gl_fake_queries_, &GlFakeQueries::Finish));
+
+      EXPECT_CALL(*gl_, QueryCounter(_, GL_TIMESTAMP))
+          .Times(AtLeast(1))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::QueryCounter));
+
+      EXPECT_CALL(*gl_, GetQueryObjectui64v(_, GL_QUERY_RESULT, NotNull()))
+          .Times(AtLeast(1))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_,
+                      &GlFakeQueries::GetQueryObjectui64v));
+
+      EXPECT_CALL(*gl_, DeleteQueriesARB(1, NotNull()))
+          .Times(AtLeast(1))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::DeleteQueriesARB));
+    }
+  }
+
+  GpuTracerType GetTracerType() { return test_tracer_type_; }
+
+  GpuTracerType test_tracer_type_;
+  GlFakeQueries gl_fake_queries_;
+
+  scoped_refptr<MockOutputter> outputter_ref_;
+  scoped_refptr<FakeCPUTime> cpu_time_ref_;
+
+  scoped_refptr<gfx::GLSurface> gl_surface_;
+  scoped_refptr<gfx::GLContext> gl_context_;
+};
+
+// Test GPUTrace calls all the correct gl calls.
+class BaseGpuTraceTest : public BaseGpuTest {
+ public:
+  BaseGpuTraceTest(GpuTracerType test_tracer_type)
+      : BaseGpuTest(test_tracer_type) {
+  }
 
   void DoTraceTest() {
-    MockOutputter* outputter = new MockOutputter();
-    scoped_refptr<Outputter> outputter_ref = outputter;
-
-    SetupTimerQueryMocks();
-
     // Expected results
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
@@ -125,13 +397,12 @@
     const int64 expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
-    // Expected Outputter::Trace call
-    EXPECT_CALL(*outputter,
-                Trace(category_name, trace_name,
-                      expect_start_time, expect_end_time));
+    ExpectTraceQueryMocks();
+    ExpectOutputterMocks(outputter_ref_.get(), category_name, trace_name,
+                         expect_start_time, expect_end_time);
 
     scoped_refptr<GPUTrace> trace =
-        new GPUTrace(outputter_ref, category_name, trace_name,
+        new GPUTrace(outputter_ref_, cpu_time_ref_, category_name, trace_name,
                      offset_time, GetTracerType());
 
     gl_fake_queries_.SetCurrentGLTime(start_timestamp);
@@ -154,73 +425,275 @@
 
     // Proces should output expected Trace results to MockOutputter
     trace->Process();
+
+    outputter_ref_ = NULL;
+    cpu_time_ref_ = NULL;
+  }
+};
+
+class GpuARBTimerTraceTest : public BaseGpuTraceTest {
+ public:
+  GpuARBTimerTraceTest()
+      : BaseGpuTraceTest(kTracerTypeARBTimer) {
+  }
+};
+
+class GpuDisjointTimerTraceTest : public BaseGpuTraceTest {
+ public:
+  GpuDisjointTimerTraceTest()
+      : BaseGpuTraceTest(kTracerTypeDisjointTimer) {
+  }
+};
+
+TEST_F(GpuARBTimerTraceTest, ARBTimerTraceTest) {
+  DoTraceTest();
+}
+
+TEST_F(GpuDisjointTimerTraceTest, DisjointTimerTraceTest) {
+  DoTraceTest();
+}
+
+// Test GPUTracer calls all the correct gl calls.
+class BaseGpuTracerTest : public BaseGpuTest {
+ public:
+  BaseGpuTracerTest(GpuTracerType test_tracer_type)
+      : BaseGpuTest(test_tracer_type) {
   }
 
- protected:
-  void SetUp() override {
-    GpuServiceTest::SetUp();
-    gl_fake_queries_.Reset();
+  void DoBasicTracerTest() {
+    ExpectTracerOffsetQueryMocks();
+
+    MockGLES2Decoder decoder;
+    GPUTracerTester tracer(test_tracer_type_, &decoder);
+    tracer.SetTracingEnabled(true);
+
+    tracer.SetOutputter(outputter_ref_);
+    tracer.SetCPUTime(cpu_time_ref_);
+
+    ASSERT_TRUE(tracer.BeginDecoding());
+    ASSERT_TRUE(tracer.EndDecoding());
+
+    outputter_ref_ = NULL;
+    cpu_time_ref_ = NULL;
   }
 
-  void TearDown() override {
-    gl_.reset();
-    gl_fake_queries_.Reset();
-    GpuServiceTest::TearDown();
+  void DoTracerMarkersTest() {
+    ExpectTracerOffsetQueryMocks();
+
+    EXPECT_CALL(*gl_, GetError()).Times(AtLeast(0))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::GetError));
+
+    const std::string category_name("trace_category");
+    const std::string trace_name("trace_test");
+    const int64 offset_time = 3231;
+    const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
+    const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
+    const int64 expect_start_time =
+        (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
+        offset_time;
+    const int64 expect_end_time =
+        (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
+
+    MockGLES2Decoder decoder;
+    GPUTracerTester tracer(test_tracer_type_, &decoder);
+    tracer.SetTracingEnabled(true);
+
+    tracer.SetOutputter(outputter_ref_);
+    tracer.SetCPUTime(cpu_time_ref_);
+
+    gl_fake_queries_.SetCurrentGLTime(start_timestamp);
+    cpu_time_ref_->SetFakeCPUTime(expect_start_time);
+
+    ASSERT_TRUE(tracer.BeginDecoding());
+
+    ExpectTraceQueryMocks();
+
+    // This will test multiple marker sources which overlap one another.
+    for (int i = 0; i < NUM_TRACER_SOURCES; ++i) {
+      // Set times so each source has a different time.
+      gl_fake_queries_.SetCurrentGLTime(
+          start_timestamp +
+          (i * base::Time::kNanosecondsPerMicrosecond));
+      cpu_time_ref_->SetFakeCPUTime(expect_start_time + i);
+
+      // Each trace name should be different to differentiate.
+      const char num_char = static_cast<char>('0' + i);
+      std::string source_category = category_name + num_char;
+      std::string source_trace_name = trace_name + num_char;
+
+      ExpectOutputterBeginMocks(outputter_ref_.get(),
+                                source_category, source_trace_name);
+
+      const GpuTracerSource source = static_cast<GpuTracerSource>(i);
+      ASSERT_TRUE(tracer.Begin(source_category, source_trace_name, source));
+    }
+
+    for (int i = 0; i < NUM_TRACER_SOURCES; ++i) {
+      // Set times so each source has a different time.
+      gl_fake_queries_.SetCurrentGLTime(
+          end_timestamp +
+          (i * base::Time::kNanosecondsPerMicrosecond));
+      cpu_time_ref_->SetFakeCPUTime(expect_end_time + i);
+
+      // Each trace name should be different to differentiate.
+      const char num_char = static_cast<char>('0' + i);
+      std::string source_category = category_name + num_char;
+      std::string source_trace_name = trace_name + num_char;
+
+      ExpectOutputterEndMocks(outputter_ref_.get(), source_category,
+                              source_trace_name,
+                              expect_start_time + i, expect_end_time + i,
+                              GetTracerType() != kTracerTypeInvalid);
+
+      const GpuTracerSource source = static_cast<GpuTracerSource>(i);
+
+      // Check if the current category/name are correct for this source.
+      ASSERT_EQ(source_category, tracer.CurrentCategory(source));
+      ASSERT_EQ(source_trace_name, tracer.CurrentName(source));
+
+      ASSERT_TRUE(tracer.End(source));
+    }
+
+    ASSERT_TRUE(tracer.EndDecoding());
+
+    outputter_ref_ = NULL;
+    cpu_time_ref_ = NULL;
   }
 
-  virtual void SetupTimerQueryMocks() {
-    // Delegate query APIs used by GPUTrace to a GlFakeQueries
-    EXPECT_CALL(*gl_, GenQueriesARB(_, NotNull())).Times(AtLeast(1)).WillOnce(
-        Invoke(&gl_fake_queries_, &GlFakeQueries::GenQueriesARB));
+  void DoDisjointTest() {
+    // Cause a disjoint in a middle of a trace and expect no output calls.
+    ExpectTracerOffsetQueryMocks();
 
-    EXPECT_CALL(*gl_, GetQueryObjectiv(_, GL_QUERY_RESULT_AVAILABLE, NotNull()))
-        .Times(AtLeast(2))
-        .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::GetQueryObjectiv));
+    EXPECT_CALL(*gl_, GetError()).Times(AtLeast(0))
+          .WillRepeatedly(
+               Invoke(&gl_fake_queries_, &GlFakeQueries::GetError));
 
-    EXPECT_CALL(*gl_, QueryCounter(_, GL_TIMESTAMP))
-        .Times(AtLeast(2))
-        .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::QueryCounter));
+    const std::string category_name("trace_category");
+    const std::string trace_name("trace_test");
+    const GpuTracerSource source = static_cast<GpuTracerSource>(0);
+    const int64 offset_time = 3231;
+    const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
+    const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
+    const int64 expect_start_time =
+        (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
+        offset_time;
+    const int64 expect_end_time =
+        (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
-    EXPECT_CALL(*gl_, GetQueryObjectui64v(_, GL_QUERY_RESULT, NotNull()))
-        .Times(AtLeast(2))
-        .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::GetQueryObjectui64v));
+    MockGLES2Decoder decoder;
+    GPUTracerTester tracer(test_tracer_type_, &decoder);
+    tracer.SetTracingEnabled(true);
 
-    EXPECT_CALL(*gl_, DeleteQueriesARB(2, NotNull()))
-        .Times(AtLeast(1))
-        .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::DeleteQueriesARB));
+    tracer.SetOutputter(outputter_ref_);
+    tracer.SetCPUTime(cpu_time_ref_);
+
+    gl_fake_queries_.SetCurrentGLTime(start_timestamp);
+    cpu_time_ref_->SetFakeCPUTime(expect_start_time);
+
+    ASSERT_TRUE(tracer.BeginDecoding());
+
+    ExpectTraceQueryMocks();
+
+    ExpectOutputterBeginMocks(outputter_ref_.get(),
+                              category_name, trace_name);
+    ASSERT_TRUE(tracer.Begin(category_name, trace_name, source));
+
+    gl_fake_queries_.SetCurrentGLTime(end_timestamp);
+    cpu_time_ref_->SetFakeCPUTime(expect_end_time);
+    gl_fake_queries_.SetDisjoint();
+
+    ExpectOutputterEndMocks(outputter_ref_.get(), category_name, trace_name,
+                            expect_start_time, expect_end_time, false);
+
+    ASSERT_TRUE(tracer.End(source));
+    ASSERT_TRUE(tracer.EndDecoding());
+
+    outputter_ref_ = NULL;
+    cpu_time_ref_ = NULL;
   }
+};
 
-  virtual GpuTracerType GetTracerType() = 0;
-
-  GlFakeQueries gl_fake_queries_;
+class InvalidTimerTracerTest : public BaseGpuTracerTest {
+ public:
+  InvalidTimerTracerTest()
+      : BaseGpuTracerTest(kTracerTypeInvalid) {
+  }
 };
 
 class GpuARBTimerTracerTest : public BaseGpuTracerTest {
- protected:
-  GpuTracerType GetTracerType() override { return kTracerTypeARBTimer; }
+ public:
+  GpuARBTimerTracerTest()
+      : BaseGpuTracerTest(kTracerTypeARBTimer) {
+  }
 };
 
 class GpuDisjointTimerTracerTest : public BaseGpuTracerTest {
- protected:
-  GpuTracerType GetTracerType() override { return kTracerTypeDisjointTimer; }
+ public:
+  GpuDisjointTimerTracerTest()
+      : BaseGpuTracerTest(kTracerTypeDisjointTimer) {
+  }
 };
 
-TEST_F(GpuARBTimerTracerTest, GPUTrace) {
-  // Test basic timer query functionality
-  {
-    DoTraceTest();
-  }
+TEST_F(InvalidTimerTracerTest, InvalidTimerBasicTracerTest) {
+  DoBasicTracerTest();
 }
 
-TEST_F(GpuDisjointTimerTracerTest, GPUTrace) {
-  // Test basic timer query functionality
-  {
-    DoTraceTest();
-  }
+TEST_F(GpuARBTimerTracerTest, ARBTimerBasicTracerTest) {
+  DoBasicTracerTest();
+}
+
+TEST_F(GpuDisjointTimerTracerTest, DisjointTimerBasicTracerTest) {
+  DoBasicTracerTest();
+}
+
+TEST_F(InvalidTimerTracerTest, InvalidTimerTracerMarkersTest) {
+  DoTracerMarkersTest();
+}
+
+TEST_F(GpuARBTimerTracerTest, ARBTimerBasicTracerMarkersTest) {
+  DoTracerMarkersTest();
+}
+
+TEST_F(GpuDisjointTimerTracerTest, DisjointTimerBasicTracerMarkersTest) {
+  DoTracerMarkersTest();
+}
+
+TEST_F(GpuDisjointTimerTracerTest, DisjointTimerDisjointTraceTest) {
+  DoDisjointTest();
+}
+
+// Test basic functionality of the GPUTracerTester.
+TEST(GPUTracerTester, IsTracingTest) {
+  MockGLES2Decoder decoder;
+  GPUTracerTester tracer_tester(kTracerTypeInvalid, &decoder);
+  EXPECT_FALSE(tracer_tester.IsTracing());
+  tracer_tester.SetTracingEnabled(true);
+  EXPECT_TRUE(tracer_tester.IsTracing());
+}
+
+TEST(GPUTracerTester, DecodeTest) {
+  MockGLES2Decoder decoder;
+  GPUTracerTester tracer_tester(kTracerTypeInvalid, &decoder);
+  ASSERT_TRUE(tracer_tester.BeginDecoding());
+  EXPECT_FALSE(tracer_tester.BeginDecoding());
+  ASSERT_TRUE(tracer_tester.EndDecoding());
+  EXPECT_FALSE(tracer_tester.EndDecoding());
+}
+
+TEST(GPUTracerTester, TraceDuringDecodeTest) {
+  MockGLES2Decoder decoder;
+  GPUTracerTester tracer_tester(kTracerTypeInvalid, &decoder);
+  const std::string category_name("trace_category");
+  const std::string trace_name("trace_test");
+
+  EXPECT_FALSE(tracer_tester.Begin(category_name, trace_name,
+                                   kTraceGroupMarker));
+
+  ASSERT_TRUE(tracer_tester.BeginDecoding());
+  EXPECT_TRUE(tracer_tester.Begin(category_name, trace_name,
+                                  kTraceGroupMarker));
+  ASSERT_TRUE(tracer_tester.EndDecoding());
 }
 
 }  // namespace gles2
diff --git a/gpu/command_buffer/service/in_process_command_buffer.cc b/gpu/command_buffer/service/in_process_command_buffer.cc
index d43f84c..c312345 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.cc
+++ b/gpu/command_buffer/service/in_process_command_buffer.cc
@@ -33,7 +33,7 @@
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
-#include "ui/gfx/size.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
diff --git a/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc b/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
index 1026f45..621e6a1 100644
--- a/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
+++ b/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
@@ -7,7 +7,7 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "gpu/command_buffer/service/texture_manager.h"
-#include "ui/gfx/size.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image.h"
diff --git a/gpu/command_buffer/tests/gl_manager.h b/gpu/command_buffer/tests/gl_manager.h
index 7a3eb2c..cad1469 100644
--- a/gpu/command_buffer/tests/gl_manager.h
+++ b/gpu/command_buffer/tests/gl_manager.h
@@ -10,8 +10,8 @@
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/client/gpu_control.h"
 #include "gpu/command_buffer/service/feature_info.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
-#include "ui/gfx/size.h"
 
 namespace base {
 class CommandLine;