[Ozone-DRI] Convert HardwareDisplayController to use scanout buffers

ui/ozone/platform/dri/dri_surface_factory_unittest.cc

 // Copyright 2014 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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "ui/ozone/platform/dri/dri_buffer.h"
 #include "ui/ozone/platform/dri/dri_surface.h"
 #include "ui/ozone/platform/dri/dri_surface_factory.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/platform/dri/test/mock_dri_wrapper.h"
-#include "ui/ozone/platform/dri/test/mock_surface_generator.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 
 namespace {
 
 const drmModeModeInfo kDefaultMode =

[alexst (slow to review), 2014/07/21 20:56:24]

So I was trying to understand what the code below does and while it's not part
of this particular CL, it would help others who go spelunking into this test to
understand what fields the magic values map to.

For example, what size is our hdisplay? It's hard to tell without looking at
drm.

[dnicoara, 2014/07/21 21:02:12]

Done.

[alexst (slow to review), 2014/07/22 12:33:16]

I meant please annotate all the fields so next person knows what the magic
numbers mean.

[dnicoara, 2014/07/22 13:51:30]

Ah, sorry, I misunderstood your comment.

I don't think it makes sense to annotate all the fields given that only 2 fields
are actually initialized to used values. I'd prefer the reader to go to the
header file since that would contain more details.

     {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}};
 
 class MockScreenManager : public ui::ScreenManager {
  public:
   MockScreenManager(ui::DriWrapper* dri,
-                    ui::ScanoutSurfaceGenerator* surface_generator)
-      : ScreenManager(dri, surface_generator),
+                    ui::ScanoutBufferGenerator* buffer_generator)
+      : ScreenManager(dri, buffer_generator),
         dri_(dri) {}
   virtual ~MockScreenManager() {}
 
   // Normally we'd use DRM to figure out the controller configuration. But we
   // can't use DRM in unit tests, so we just create a fake configuration.
   virtual void ForceInitializationOfPrimaryDisplay() OVERRIDE {
     ConfigureDisplayController(1, 2, kDefaultMode);
   }
 
  private:
   ui::DriWrapper* dri_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(MockScreenManager);
 };
 
 }  // namespace
 
 class DriSurfaceFactoryTest : public testing::Test {
  public:
   DriSurfaceFactoryTest() {}
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
  protected:
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<ui::MockDriWrapper> dri_;
-  scoped_ptr<ui::MockSurfaceGenerator> surface_generator_;
+  scoped_ptr<ui::DriBufferGenerator> buffer_generator_;
   scoped_ptr<MockScreenManager> screen_manager_;
   scoped_ptr<ui::DriSurfaceFactory> factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DriSurfaceFactoryTest);
 };
 
 void DriSurfaceFactoryTest::SetUp() {
   message_loop_.reset(new base::MessageLoopForUI);
   dri_.reset(new ui::MockDriWrapper(3));
-  surface_generator_.reset(new ui::MockSurfaceGenerator(dri_.get()));
+  buffer_generator_.reset(new ui::DriBufferGenerator(dri_.get()));
   screen_manager_.reset(new MockScreenManager(dri_.get(),
-                                              surface_generator_.get()));
+                                              buffer_generator_.get()));
   factory_.reset(new ui::DriSurfaceFactory(dri_.get(), screen_manager_.get()));
 }
 
 void DriSurfaceFactoryTest::TearDown() {
   factory_.reset();
   message_loop_.reset();
 }
 
 TEST_F(DriSurfaceFactoryTest, FailInitialization) {
   dri_->fail_init();
@@ skipping 30 matching lines @@
 
   SkPaint paint;
   paint.setColor(SK_ColorWHITE);
   SkRect rect = SkRect::MakeWH(kDefaultMode.hdisplay / 2,
                                kDefaultMode.vdisplay / 2);
   surface->GetCanvas()->drawRect(rect, paint);
   surface->PresentCanvas(
       gfx::Rect(0, 0, kDefaultMode.hdisplay / 2, kDefaultMode.vdisplay / 2));
 
   SkBitmap image;
-  // Buffers 0 and 1 are the cursor buffers and 2 and 3 are the surface buffers.
-  // Buffer 3 is the backbuffer we just painted in, so we want to make sure its
+  // Buffers 0 and 1 are the cursor buffers, 2 is the modeset buffer, and
+  // 3 and 4 are the surface buffers.
+  // Buffer 4 is the backbuffer we just painted in, so we want to make sure its
   // contents are correct.
-  image.setInfo(dri_->buffers()[3]->getCanvas()->imageInfo());
-  EXPECT_TRUE(dri_->buffers()[3]->getCanvas()->readPixels(&image, 0, 0));
+  image.setInfo(dri_->buffers()[4]->getCanvas()->imageInfo());
+  EXPECT_TRUE(dri_->buffers()[4]->getCanvas()->readPixels(&image, 0, 0));
 
   EXPECT_EQ(kDefaultMode.hdisplay, image.width());
   EXPECT_EQ(kDefaultMode.vdisplay, image.height());
 
   // Make sure the updates are correctly propagated to the native surface.
   for (int i = 0; i < image.height(); ++i) {
     for (int j = 0; j < image.width(); ++j) {
       if (j < kDefaultMode.hdisplay / 2 && i < kDefaultMode.vdisplay / 2)
         EXPECT_EQ(SK_ColorWHITE, image.getColor(j, i));
       else
@@ skipping 29 matching lines @@
   for (int i = 0; i < cursor.height(); ++i) {
     for (int j = 0; j < cursor.width(); ++j) {
       if (j < info.width() && i < info.height())
         EXPECT_EQ(SK_ColorWHITE, cursor.getColor(j, i));
       else
         EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
                   cursor.getColor(j, i));
     }
   }
 }