Roll Chrome into Mojo.
This roll corresponds to:
https://chromium.googlesource.com/chromium/src/+/d3cf92cac313434de99ae66f6e3e12d27ab536ef
GN now requires python_binary_module to be undefined rather than an empty string.
Context lines in cc_strip_video.patch changed.
Minor edits were required for sky:
Change to Skia header file organization.
SkRect::intersect now warns if ignored.
BUG=https://code.google.com/p/chromium/issues/detail?id=401761
R=jamesr@chromium.org
Review URL: https://codereview.chromium.org/839143002
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;
