Plumb surface id to GpuMemoryBuffer allocation.

We need to know which display controller to use for allocation of scanout buffers in situations where an external USB monitor is connected.

BUG=432550

Review URL: https://codereview.chromium.org/725723002

Cr-Commit-Position: refs/heads/master@{#307317}

1 files changed, 58 insertions, 12 deletions

diff --git a/content/browser/compositor/buffer_queue_unittest.cc b/content/browser/compositor/buffer_queue_unittest.cc
index 1a2c4fe..8506b58 100644
--- a/content/browser/compositor/buffer_queue_unittest.cc
+++ b/content/browser/compositor/buffer_queue_unittest.cc
@@ -8,6 +8,7 @@
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "content/browser/compositor/buffer_queue.h"
 #include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
+#include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -19,11 +20,48 @@ using ::testing::Ne;
 using ::testing::Return;
 
 namespace content {
+
+class StubGpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
+ public:
+  StubGpuMemoryBufferImpl() {}
+
+  // Overridden from gfx::GpuMemoryBuffer:
+  void* Map() override { return nullptr; }
+  void Unmap() override {}
+  bool IsMapped() const override { return false; }
+  Format GetFormat() const override { return gfx::GpuMemoryBuffer::RGBX_8888; }
+  uint32 GetStride() const override { return 0; }
+  gfx::GpuMemoryBufferHandle GetHandle() const override {
+    return gfx::GpuMemoryBufferHandle();
+  }
+  ClientBuffer AsClientBuffer() override {
+    return reinterpret_cast<ClientBuffer>(this);
+  }
+};
+
+class StubBrowserGpuMemoryBufferManager : public BrowserGpuMemoryBufferManager {
+ public:
+  StubBrowserGpuMemoryBufferManager()
+      : BrowserGpuMemoryBufferManager(nullptr, 1) {}
+
+  scoped_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBufferForScanout(
+      const gfx::Size& size,
+      gfx::GpuMemoryBuffer::Format format,
+      int32 surface_id) override {
+    return make_scoped_ptr<gfx::GpuMemoryBuffer>(new StubGpuMemoryBufferImpl);
+  }
+};
+
 class MockBufferQueue : public BufferQueue {
  public:
   MockBufferQueue(scoped_refptr<cc::ContextProvider> context_provider,
+                  BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager,
                   unsigned int internalformat)
-      : BufferQueue(context_provider, internalformat, nullptr) {}
+      : BufferQueue(context_provider,
+                    internalformat,
+                    nullptr,
+                    gpu_memory_buffer_manager,
+                    1) {}
   MOCK_METHOD4(CopyBufferDamage,
                void(int, int, const gfx::Rect&, const gfx::Rect&));
 };
@@ -36,7 +74,9 @@ class BufferQueueTest : public ::testing::Test {
     scoped_refptr<cc::TestContextProvider> context_provider =
         cc::TestContextProvider::Create(cc::TestWebGraphicsContext3D::Create());
     context_provider->BindToCurrentThread();
-    output_surface_.reset(new MockBufferQueue(context_provider, GL_RGBA));
+    gpu_memory_buffer_manager_.reset(new StubBrowserGpuMemoryBufferManager);
+    output_surface_.reset(new MockBufferQueue(
+        context_provider, gpu_memory_buffer_manager_.get(), GL_RGBA));
     output_surface_->Initialize();
   }
 
@@ -102,6 +142,7 @@ class BufferQueueTest : public ::testing::Test {
     return true;
   }
 
+  scoped_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager_;
   scoped_ptr<MockBufferQueue> output_surface_;
   bool doublebuffering_;
   bool first_frame_;
@@ -119,29 +160,33 @@ class MockedContext : public cc::TestWebGraphicsContext3D {
   MOCK_METHOD2(bindFramebuffer, void(GLenum, GLuint));
   MOCK_METHOD2(bindTexture, void(GLenum, GLuint));
   MOCK_METHOD2(bindTexImage2DCHROMIUM, void(GLenum, GLint));
-  MOCK_METHOD4(createGpuMemoryBufferImageCHROMIUM,
-               GLuint(GLsizei, GLsizei, GLenum, GLenum));
+  MOCK_METHOD4(createImageCHROMIUM,
+               GLuint(ClientBuffer, GLsizei, GLsizei, GLenum));
   MOCK_METHOD1(destroyImageCHROMIUM, void(GLuint));
   MOCK_METHOD5(framebufferTexture2D,
                void(GLenum, GLenum, GLenum, GLuint, GLint));
 };
 
-scoped_ptr<BufferQueue> CreateOutputSurfaceWithMock(MockedContext** context) {
+scoped_ptr<BufferQueue> CreateOutputSurfaceWithMock(
+    MockedContext** context,
+    BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager) {
   *context = new MockedContext();
   scoped_refptr<cc::TestContextProvider> context_provider =
       cc::TestContextProvider::Create(
           scoped_ptr<cc::TestWebGraphicsContext3D>(*context));
   context_provider->BindToCurrentThread();
-  scoped_ptr<BufferQueue> buffer_queue(
-      new BufferQueue(context_provider, GL_RGBA, nullptr));
+  scoped_ptr<BufferQueue> buffer_queue(new BufferQueue(
+      context_provider, GL_RGBA, nullptr, gpu_memory_buffer_manager, 1));
   buffer_queue->Initialize();
   return buffer_queue.Pass();
 }
 
 TEST(BufferQueueStandaloneTest, FboInitialization) {
   MockedContext* context;
+  scoped_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager(
+      new StubBrowserGpuMemoryBufferManager);
   scoped_ptr<BufferQueue> output_surface =
-      CreateOutputSurfaceWithMock(&context);
+      CreateOutputSurfaceWithMock(&context, gpu_memory_buffer_manager.get());
 
   EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
   ON_CALL(*context, framebufferTexture2D(_, _, _, _, _))
@@ -152,14 +197,15 @@ TEST(BufferQueueStandaloneTest, FboInitialization) {
 
 TEST(BufferQueueStandaloneTest, FboBinding) {
   MockedContext* context;
+  scoped_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager(
+      new StubBrowserGpuMemoryBufferManager);
   scoped_ptr<BufferQueue> output_surface =
-      CreateOutputSurfaceWithMock(&context);
+      CreateOutputSurfaceWithMock(&context, gpu_memory_buffer_manager.get());
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, Ne(0U)));
   EXPECT_CALL(*context, destroyImageCHROMIUM(1));
   Expectation image =
-      EXPECT_CALL(*context,
-                  createGpuMemoryBufferImageCHROMIUM(
-                      0, 0, GL_RGBA, GL_SCANOUT_CHROMIUM)).WillOnce(Return(1));
+      EXPECT_CALL(*context, createImageCHROMIUM(_, 0, 0, GL_RGBA))
+          .WillOnce(Return(1));
   Expectation fb =
       EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
   Expectation tex = EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, Ne(0U)));