Adds a GLMock object so we can check the code is...

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 #include <string>
 #include <map>
 #include <build/build_config.h>
 #include "base/scoped_ptr.h"
 #define GLES2_GPU_SERVICE 1
@@ skipping 122 matching lines @@
     case GLErrorBit::kInvalidFrameBufferOperation:
       return GL_INVALID_FRAMEBUFFER_OPERATION;
     default:
       DCHECK(false);
       return GL_NO_ERROR;
   }
 }
 
 }  // anonymous namespace.
 
-#if defined(OS_LINUX)
+#if defined(UNIT_TEST)
+GLES2Decoder::GLES2Decoder() {
+#elif defined(OS_LINUX)
 GLES2Decoder::GLES2Decoder()
     : debug_(false),
       window_(NULL) {
 #elif defined(OS_WIN)
 GLES2Decoder::GLES2Decoder()
     : debug_(false),
       hwnd_(NULL) {
 #else
 GLES2Decoder::GLES2Decoder() {
 #endif
@@ skipping 356 matching lines @@
   BufferInfoMap buffer_infos_;
 
   // Info for each "successfully linked" program by service side program Id.
   // TODO(gman): Choose a faster container.
   typedef std::map<GLuint, ProgramInfo> ProgramInfoMap;
   ProgramInfoMap program_infos_;
 
   // The program in current use through glUseProgram.
   ProgramInfo* current_program_info_;
 
-#if defined(OS_WIN)
+#if defined(UNIT_TEST)
+#elif defined(OS_WIN)
   HDC device_context_;
   HGLRC gl_context_;
 #endif
 
   bool anti_aliased_;
 
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 GLES2Decoder* GLES2Decoder::Create() {
   return new GLES2DecoderImpl();
 }
 
 GLES2DecoderImpl::GLES2DecoderImpl()
     : GLES2Decoder(),
       error_bits_(0),
       util_(0),  // TODO(gman): Set to actual num compress texture formats.
       pack_alignment_(4),
       unpack_alignment_(4),
       bound_array_buffer_(0),
       bound_element_array_buffer_(0),
       max_vertex_attribs_(0),
       current_program_info_(NULL),
-#ifdef OS_WIN
+#if defined(UNIT_TEST)
+#elif defined(OS_WIN)
       device_context_(NULL),
       gl_context_(NULL),
 #endif
       anti_aliased_(false) {
 }
 
 bool GLES2DecoderImpl::Initialize() {
   if (!InitPlatformSpecific())
     return false;
   if (!InitGlew())
     return false;
   CHECK_GL_ERROR();
 
   // Lookup GL things we need to know.
   GLint value;
   glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value);
   max_vertex_attribs_ = value;
 
   DCHECK_GE(max_vertex_attribs_, 8u);
 
   vertex_attrib_infos_.reset(new VertexAttribInfo[max_vertex_attribs_]);
   memset(vertex_attrib_infos_.get(), 0,
          sizeof(vertex_attrib_infos_[0]) * max_vertex_attribs_);
 
   //glBindFramebuffer(0, 0);
   return true;
 }
 
-#if defined(OS_WIN)
 namespace {
 
+#if defined(UNIT_TEST)
+#elif defined(OS_WIN)
+
 const PIXELFORMATDESCRIPTOR kPixelFormatDescriptor = {
   sizeof(kPixelFormatDescriptor),    // Size of structure.
   1,                       // Default version.
   PFD_DRAW_TO_WINDOW |     // Window drawing support.
   PFD_SUPPORT_OPENGL |     // OpenGL support.
   PFD_DOUBLEBUFFER,        // Double buffering support (not stereo).
   PFD_TYPE_RGBA,           // RGBA color mode (not indexed).
   24,                      // 24 bit color mode.
   0, 0, 0, 0, 0, 0,        // Don't set RGB bits & shifts.
   8, 0,                    // 8 bit alpha
@@ skipping 146 matching lines @@
 
   ::wglMakeCurrent(intermediate_dc, NULL);
   ::wglDeleteContext(gl_context);
   ::ReleaseDC(intermediate_window, intermediate_dc);
   ::DestroyWindow(intermediate_window);
   ::UnregisterClass(reinterpret_cast<wchar_t*>(class_registration),
                     module_handle);
   return true;
 }
 
+#endif  // OS_WIN
+
 // These commands convert from c calls to local os calls.
 void GLGenBuffersHelper(
     GLES2DecoderImpl*, GLsizei n, GLuint* ids) {
   glGenBuffersARB(n, ids);
 }
 
 void GLGenFramebuffersHelper(
     GLES2DecoderImpl*, GLsizei n, GLuint* ids) {
   glGenFramebuffersEXT(n, ids);
 }
@@ skipping 25 matching lines @@
     GLES2DecoderImpl*, GLsizei n, GLuint* ids) {
   glDeleteRenderbuffersEXT(n, ids);
 }
 
 void GLDeleteTexturesHelper(
     GLES2DecoderImpl*, GLsizei n, GLuint* ids) {
   glDeleteTextures(n, ids);
 }
 
 }  // anonymous namespace
-#endif
 
 bool GLES2DecoderImpl::RegisterObjects(
     GLsizei n, const GLuint* client_ids, const GLuint* service_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (!id_map_.AddMapping(client_ids[ii], service_ids[ii])) {
       // TODO(gman): fail.
     }
   }
   return true;
 }
@@ skipping 13 matching lines @@
 void GLES2DecoderImpl::RemoveBufferInfo(GLuint buffer_id) {
   for (GLuint ii = 0; ii < max_vertex_attribs_; ++ii) {
     if (vertex_attrib_infos_[ii].buffer() == buffer_id) {
       vertex_attrib_infos_[ii].Clear();
     }
   }
   buffer_infos_.erase(buffer_id);
 }
 
 bool GLES2DecoderImpl::InitPlatformSpecific() {
-#if defined(OS_WIN)
+#if defined(UNIT_TEST)
+#elif defined(OS_WIN)
   device_context_ = ::GetDC(hwnd());
 
   int pixel_format;
 
   if (!GetWindowsPixelFormat(hwnd(),
                              anti_aliased_,
                              &pixel_format)) {
       DLOG(ERROR) << "Unable to determine optimal pixel format for GL context.";
       return false;
   }
@@ skipping 19 matching lines @@
   if (!window()->Initialize())
     return false;
   if (!window()->MakeCurrent())
     return false;
 #endif
 
   return true;
 }
 
 bool GLES2DecoderImpl::InitGlew() {
+#if !defined(UNIT_TEST)
   DLOG(INFO) << "Initializing GL and GLEW for GLES2Decoder.";
 
   GLenum glew_error = glewInit();
   if (glew_error != GLEW_OK) {
     DLOG(ERROR) << "Unable to initialise GLEW : "
                 << ::glewGetErrorString(glew_error);
     return false;
   }
 
   // Check to see that we can use the OpenGL vertex attribute APIs
@@ skipping 29 matching lines @@
   if (!GLEW_VERSION_1_4 && !GLEW_EXT_blend_func_separate) {
     DLOG(ERROR) <<"Separate blend func extension missing.";
     extensions_found = false;
   }
   if (!GLEW_VERSION_2_0 && !GLEW_EXT_blend_equation_separate) {
     DLOG(ERROR) << "Separate blend function extension missing.";
     extensions_found = false;
   }
   if (!extensions_found)
     return false;
+#endif
 
   return true;
 }
 
 void GLES2DecoderImpl::Destroy() {
-#ifdef OS_LINUX
+#if defined(UNIT_TEST)
+#elif defined(OS_LINUX)
   DCHECK(window());
   window()->Destroy();
 #endif
 }
 
 const char* GLES2DecoderImpl::GetCommandName(unsigned int command_id) const {
   if (command_id > kStartPoint && command_id < kNumCommands) {
     return gles2::GetCommandName(static_cast<CommandId>(command_id));
   }
   return GetCommonCommandName(static_cast<cmd::CommandId>(command_id));
@@ skipping 140 matching lines @@
     RemoveProgramInfo(program);
     SetGLError(error);
   } else {
     UpdateProgramInfo(program);
   }
 };
 
 // NOTE: If you need to know the results of SwapBuffers (like losing
 //    the context) then add a new command. Do NOT make SwapBuffers synchronous.
 void GLES2DecoderImpl::DoSwapBuffers() {
-#ifdef OS_WIN
+#if defined(UNIT_TEST)
+#elif defined(OS_WIN)
   ::SwapBuffers(device_context_);
-#endif
-
-#ifdef OS_LINUX
+#elif defined(OS_LINUX)
   DCHECK(window());
   window()->SwapBuffers();
 #endif
 }
 
 void GLES2DecoderImpl::DoUseProgram(GLuint program) {
   ProgramInfo* info = GetProgramInfo(program);
   if (!info) {
     // Program was not linked successfully. (ie, glLinkProgram)
     SetGLError(GL_INVALID_OPERATION);
@@ skipping 615 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu