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
  92   MOCK_METHOD5(Init, bool(
  93       sh::GLenum shader_type,
  94       ShShaderSpec shader_spec,
  95       const ShBuiltInResources* resources,
  96       GlslImplementationType glsl_implementation_type,
  97       ShCompileOptions driver_bug_workarounds));
  98   MOCK_CONST_METHOD7(Translate, bool(
  99       const std::string& shader_source,
 100       std::string* info_log,
 101       std::string* translated_source,
 102       AttributeMap* attrib_map,
 103       UniformMap* uniform_map,
 104       VaryingMap* varying_map,
 105       NameMap* name_map));
 106   MOCK_CONST_METHOD0(
 107       GetStringForOptionsThatWouldAffectCompilation, std::string());
 108  private:
 109   ~MockShaderTranslator() override;
 110 };
 111
 112 class MockProgramCache : public ProgramCache {
 113  public:
 114   MockProgramCache();
 115   virtual ~MockProgramCache();
 116
 117   MOCK_METHOD7(LoadLinkedProgram, ProgramLoadResult(
 118       GLuint program,
 119       Shader* shader_a,
 120       Shader* shader_b,
 121       const LocationMap* bind_attrib_location_map,
 122       const std::vector<std::string>& transform_feedback_varyings,
 123       GLenum transform_feedback_buffer_mode,
 124       const ShaderCacheCallback& callback));
 125
 126   MOCK_METHOD7(SaveLinkedProgram, void(
 127       GLuint program,
 128       const Shader* shader_a,
 129       const Shader* shader_b,
 130       const LocationMap* bind_attrib_location_map,
 131       const std::vector<std::string>& transform_feedback_varyings,
 132       GLenum transform_feedback_buffer_mode,
 133       const ShaderCacheCallback& callback));
 134   MOCK_METHOD1(LoadProgram, void(const std::string&));
 135
 136  private:
 137   MOCK_METHOD0(ClearBackend, void());
 138 };
 139
 140 class MockMemoryTracker : public MemoryTracker {
 141  public:
 142   MockMemoryTracker();
 143
 144   MOCK_METHOD3(TrackMemoryAllocatedChange, void(
 145       size_t old_size, size_t new_size, Pool pool));
 146   MOCK_METHOD1(EnsureGPUMemoryAvailable, bool(size_t size_needed));
 147
 148  private:
 149   friend class ::testing::StrictMock<MockMemoryTracker>;
 150   friend class base::RefCounted< ::testing::StrictMock<MockMemoryTracker> >;
 151   virtual ~MockMemoryTracker();
 152 };
 153
 154 }  // namespace gles2
 155 }  // namespace gpu
 156
 157 #endif  // GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_