Refactored GLContext to own GPUTiming which spawn GPUTimingClients.

ui/gl/gpu_timing.h

 // Copyright (c) 2015 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 GPU_COMMAND_BUFFER_SERVICE_GPU_TIMING_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GPU_TIMING_H_
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
-#include "gpu/gpu_export.h"
 
 namespace gfx {
 class GLContext;
 }
 
 namespace gpu {
-class GPUTiming;
+
+class GPUTimingClient;
+
+class GL_EXPORT GPUTiming {
+ public:
+  enum TimerType {
+    kTimerTypeInvalid = -1,
+
+    kTimerTypeARB,      // ARB_timer_query
+    kTimerTypeDisjoint  // EXT_disjoint_timer_query
+  };
+
+  explicit GPUTiming(gfx::GLContext* context = nullptr);
+  virtual ~GPUTiming();
+
+  void Initialize(gfx::GLContext* context);
+
+  TimerType GetTimerType() const { return timer_type_; }
+
+  scoped_refptr<GPUTimingClient> CreateGPUTimingClient();
+
+ private:
+  TimerType timer_type_ = kTimerTypeInvalid;
+  DISALLOW_COPY_AND_ASSIGN(GPUTiming);
+};
 
 // Class to compute the amount of time it takes to fully
 // complete a set of GL commands
-class GPU_EXPORT GPUTimer {
+class GL_EXPORT GPUTimer {
  public:
-  // gpu_timing must outlive GPUTimer instance we're creating.
-  explicit GPUTimer(GPUTiming* gpu_timing);
+  // gpu_timing_client must outlive GPUTimer instance we're creating.
+  explicit GPUTimer(GPUTimingClient* gpu_timing_client);
   ~GPUTimer();
 
   void Start();
   void End();
   bool IsAvailable();
 
   void GetStartEndTimestamps(int64* start, int64* end);
   int64 GetDeltaElapsed();
 
  private:
   unsigned int queries_[2];
   int64 offset_ = 0;
   bool end_requested_ = false;
-  GPUTiming* gpu_timing_;
+  GPUTimingClient* gpu_timing_client_;
 
   DISALLOW_COPY_AND_ASSIGN(GPUTimer);
 };
 
-// GPUTiming contains all the gl timing logic that is not specific
+// GPUTimingClient contains all the gl timing logic that is not specific
 // to a single GPUTimer.
-class GPU_EXPORT GPUTiming {
+class GL_EXPORT GPUTimingClient
+    : public base::RefCounted<GPUTimingClient> {
  public:
-  enum TimerType {
-    kTimerTypeInvalid = -1,
+  explicit GPUTimingClient(GPUTiming* gpu_timing = nullptr);
 
-    kTimerTypeARB,      // ARB_timer_query
-    kTimerTypeDisjoint  // EXT_disjoint_timer_query
-  };
-
-  GPUTiming();
-  virtual ~GPUTiming();
-
-  bool Initialize(gfx::GLContext* context);
   bool IsAvailable();
+  const char* GetTimerTypeName() const;
 
   // CheckAndResetTimerErrors has to be called before reading timestamps
   // from GPUTimers instances and after making sure all the timers
   // were available.
   // If the returned value is false, all the previous timers should be
   // discarded.
   bool CheckAndResetTimerErrors();
 
-  const char* GetTimerTypeName() const;
-
   // Returns the offset between the current gpu time and the cpu time.
   int64 CalculateTimerOffset();
   void InvalidateTimerOffset();
 
   void SetCpuTimeForTesting(const base::Callback<int64(void)>& cpu_time);
-  void SetOffsetForTesting(int64 offset, bool cache_it);
-  void SetTimerTypeForTesting(TimerType type);
 
- private:
-  TimerType timer_type_ = kTimerTypeInvalid;
+ protected:
+  virtual ~GPUTimingClient();
+
+  GPUTiming* gpu_timing_;
+  GPUTiming::TimerType timer_type_ = GPUTiming::kTimerTypeInvalid;
   int64 offset_ = 0;  // offset cache when timer_type_ == kTimerTypeARB
   bool offset_valid_ = false;
   base::Callback<int64(void)> cpu_time_for_testing_;
+
+  friend class base::RefCounted<GPUTimingClient>;
   friend class GPUTimer;
-  DISALLOW_COPY_AND_ASSIGN(GPUTiming);
+  friend class GPUTiming;
+  DISALLOW_COPY_AND_ASSIGN(GPUTimingClient);
 };
+
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GPU_TIMING_H_