src/gpu/command_buffer/service/mocks.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file contains definitions for mock objects, used for testing.
   6
   7 // TODO(apatrick): This file "manually" defines some mock objects. Using gMock
   8 // would be definitely preferable, unfortunately it doesn't work on Windows yet.
   9
  10 #ifndef GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_
  11 #define GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_
  12
  13 #include <string>
  14 #include <vector>
  15
  16 #include "base/logging.h"
  17 #include "gpu/command_buffer/service/cmd_parser.h"
  18 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
  19 #include "gpu/command_buffer/service/memory_tracking.h"
  20 #include "gpu/command_buffer/service/program_cache.h"
  21 #include "gpu/command_buffer/service/shader_translator.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23
  24 namespace gpu {
  25
  26 // Mocks an AsyncAPIInterface, using GMock.
  27 class AsyncAPIMock : public AsyncAPIInterface {
  28  public:
  29   explicit AsyncAPIMock(bool default_do_commands);
  30   virtual ~AsyncAPIMock();
  31
  32   error::Error FakeDoCommands(unsigned int num_commands,
  33                               const void* buffer,
  34                               int num_entries,
  35                               int* entries_processed);
  36
  37   // Predicate that matches args passed to DoCommand, by looking at the values.
  38   class IsArgs {
  39    public:
  40     IsArgs(unsigned int arg_count, const void* args)
  41         : arg_count_(arg_count),
  42           args_(static_cast<CommandBufferEntry*>(const_cast<void*>(args))) {
  43     }
  44
  45     bool operator() (const void* _args) const {
  46       const CommandBufferEntry* args =
  47           static_cast<const CommandBufferEntry*>(_args) + 1;
  48       for (unsigned int i = 0; i < arg_count_; ++i) {
  49         if (args[i].value_uint32 != args_[i].value_uint32) return false;
  50       }
  51       return true;
  52     }
  53
  54    private:
  55     unsigned int arg_count_;
  56     CommandBufferEntry *args_;
  57   };
  58
  59   MOCK_METHOD3(DoCommand, error::Error(
  60       unsigned int command,
  61       unsigned int arg_count,
  62       const void* cmd_data));
  63
  64   MOCK_METHOD4(DoCommands,
  65                error::Error(unsigned int num_commands,
  66                             const void* buffer,
  67                             int num_entries,
  68                             int* entries_processed));
  69
  70   const char* GetCommandName(unsigned int command_id) const {
  71     return "";
  72   };
  73
  74   // Sets the engine, to forward SetToken commands to it.
  75   void set_engine(CommandBufferEngine *engine) { engine_ = engine; }
  76
  77   // Forwards the SetToken commands to the engine.
  78   void SetToken(unsigned int command,
  79                 unsigned int arg_count,
  80                 const void* _args);
  81
  82  private:
  83   CommandBufferEngine *engine_;
  84 };
  85
  86 namespace gles2 {
  87
  88 class MockShaderTranslator : public ShaderTranslatorInterface {
  89  public:
  90   MockShaderTranslator();
  91   virtual ~MockShaderTranslator();
  92
  93   MOCK_METHOD5(Init, bool(
  94       sh::GLenum shader_type,
  95       ShShaderSpec shader_spec,
  96       const ShBuiltInResources* resources,
  97       GlslImplementationType glsl_implementation_type,
  98       ShCompileOptions driver_bug_workarounds));
  99   MOCK_CONST_METHOD7(Translate, bool(
 100       const std::string& shader_source,
 101       std::string* info_log,
 102       std::string* translated_source,
 103       AttributeMap* attrib_map,
 104       UniformMap* uniform_map,
 105       VaryingMap* varying_map,
 106       NameMap* name_map));
 107   MOCK_CONST_METHOD0(
 108       GetStringForOptionsThatWouldAffectCompilation, std::string());
 109 };
 110
 111 class MockProgramCache : public ProgramCache {
 112  public:
 113   MockProgramCache();
 114   virtual ~MockProgramCache();
 115
 116   MOCK_METHOD7(LoadLinkedProgram, ProgramLoadResult(
 117       GLuint program,
 118       Shader* shader_a,
 119       const ShaderTranslatorInterface* translator_a,
 120       Shader* shader_b,
 121       const ShaderTranslatorInterface* translator_b,
 122       const LocationMap* bind_attrib_location_map,
 123       const ShaderCacheCallback& callback));
 124
 125   MOCK_METHOD7(SaveLinkedProgram, void(
 126       GLuint program,
 127       const Shader* shader_a,
 128       const ShaderTranslatorInterface* translator_a,
 129       const Shader* shader_b,
 130       const ShaderTranslatorInterface* translator_b,
 131       const LocationMap* bind_attrib_location_map,
 132       const ShaderCacheCallback& callback));
 133   MOCK_METHOD1(LoadProgram, void(const std::string&));
 134
 135  private:
 136   MOCK_METHOD0(ClearBackend, void());
 137 };
 138
 139 class MockMemoryTracker : public MemoryTracker {
 140  public:
 141   MockMemoryTracker();
 142
 143   MOCK_METHOD3(TrackMemoryAllocatedChange, void(
 144       size_t old_size, size_t new_size, Pool pool));
 145   MOCK_METHOD1(EnsureGPUMemoryAvailable, bool(size_t size_needed));
 146
 147  private:
 148   friend class ::testing::StrictMock<MockMemoryTracker>;
 149   friend class base::RefCounted< ::testing::StrictMock<MockMemoryTracker> >;
 150   virtual ~MockMemoryTracker();
 151 };
 152
 153 }  // namespace gles2
 154 }  // namespace gpu
 155
 156 #endif  // GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_