Not for review.

ui/gfx/ozone/dri/dri_surface_unittest.cc

 // Copyright 2013 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 "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/SkDevice.h"
 #include "ui/gfx/ozone/dri/dri_skbitmap.h"
 #include "ui/gfx/ozone/dri/dri_surface.h"
@@ skipping 12 matching lines @@
 const uint32_t kConnectorId = 1;
 
 // Mock CRTC ID.
 const uint32_t kCrtcId = 1;
 
 // Mock DPMS property ID.
 const uint32_t kDPMSPropertyId = 1;
 
 class MockDriWrapper : public gfx::DriWrapper {
  public:
-  MockDriWrapper() : DriWrapper(""), id_(1) { fd_ = kFd; }
+  MockDriWrapper() : DriWrapper(""),
+                     id_(1),
+                     add_framebuffer_expectation_(true) {
+    fd_ = kFd;
+  }
+
   virtual ~MockDriWrapper() { fd_ = -1; }
 
   virtual drmModeCrtc* GetCrtc(uint32_t crtc_id) OVERRIDE { return NULL; }
   virtual void FreeCrtc(drmModeCrtc* crtc) OVERRIDE {}
   virtual bool SetCrtc(uint32_t crtc_id,
                        uint32_t framebuffer,
                        uint32_t* connectors,
                        drmModeModeInfo* mode) OVERRIDE { return true; }
   virtual bool SetCrtc(drmModeCrtc* crtc, uint32_t* connectors) OVERRIDE {
     return true;
   }
   virtual bool AddFramebuffer(const drmModeModeInfo& mode,
                               uint8_t depth,
                               uint8_t bpp,
                               uint32_t stride,
                               uint32_t handle,
                               uint32_t* framebuffer) OVERRIDE {
     *framebuffer = id_++;
-    return true;
+    return add_framebuffer_expectation_;
   }
   virtual bool RemoveFramebuffer(uint32_t framebuffer) OVERRIDE { return true; }
   virtual bool PageFlip(uint32_t crtc_id,
                         uint32_t framebuffer,
                         void* data) OVERRIDE {
     return true;
   }
   virtual bool ConnectorSetProperty(uint32_t connector_id,
                                     uint32_t property_id,
                                     uint64_t value) OVERRIDE { return true; }
 
+  void set_add_framebuffer_expectation(bool state) {
+    add_framebuffer_expectation_ = state;
+  }
+
  private:
   int id_;
+
+  bool add_framebuffer_expectation_;
+
   DISALLOW_COPY_AND_ASSIGN(MockDriWrapper);
 };
 
 class MockDriSkBitmap : public gfx::DriSkBitmap {
  public:
   MockDriSkBitmap(int fd,
                        bool initialize_expectation)
       : DriSkBitmap(fd),
         initialize_expectation_(initialize_expectation) {}
   virtual ~MockDriSkBitmap() {}
@@ skipping 61 matching lines @@
 
   surface_.reset(new MockDriSurface(controller_.get()));
 }
 
 void DriSurfaceTest::TearDown() {
   surface_.reset();
   controller_.reset();
   drm_.reset();
 }
 
-TEST_F(DriSurfaceTest, FailInitialization) {
+TEST_F(DriSurfaceTest, FailInitializationInBitmapInitialization) {
   surface_->set_initialize_expectation(false);
   EXPECT_FALSE(surface_->Initialize());
 }
 
+TEST_F(DriSurfaceTest, FailInitializationInFramebufferRegistration) {
+  drm_->set_add_framebuffer_expectation(false);
+  EXPECT_FALSE(surface_->Initialize());
+}
+
 TEST_F(DriSurfaceTest, SuccessfulInitialization) {
   EXPECT_TRUE(surface_->Initialize());
 }
 
 TEST_F(DriSurfaceTest, CheckFBIDOnSwap) {
   EXPECT_TRUE(surface_->Initialize());
   controller_->BindSurfaceToController(
-      surface_.PassAs<gfx::DriSurface>());
+      surface_.PassAs<gfx::ScanoutSurface>());
 
   // Check that the framebuffer ID is correct.
   EXPECT_EQ(2u, controller_->get_surface()->GetFramebufferId());
 
   controller_->get_surface()->SwapBuffers();
 
   EXPECT_EQ(1u, controller_->get_surface()->GetFramebufferId());
 }
 
 TEST_F(DriSurfaceTest, CheckPixelPointerOnSwap) {
@@ skipping 33 matching lines @@
     for (int j = 0; j < canvas->getDeviceSize().width(); ++j) {
       if (i < clip.height() && j < clip.width())
         EXPECT_EQ(SK_ColorWHITE,
                   canvas->getDevice()->accessBitmap(false).getColor(j, i));
       else
         EXPECT_EQ(SK_ColorBLACK,
                   canvas->getDevice()->accessBitmap(false).getColor(j, i));
     }
   }
 }