[Ozone] Rename software implementation files to use Dri prefix

ui/gfx/ozone/impl/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/impl/drm_skbitmap_ozone.h"
-#include "ui/gfx/ozone/impl/hardware_display_controller_ozone.h"
-#include "ui/gfx/ozone/impl/software_surface_ozone.h"
+#include "ui/gfx/ozone/impl/dri_skbitmap.h"
+#include "ui/gfx/ozone/impl/dri_surface.h"
+#include "ui/gfx/ozone/impl/hardware_display_controller.h"
 
 namespace {
 
 // Create a basic mode for a 6x4 screen.
 const drmModeModeInfo kDefaultMode =
     {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}};
 
 // Mock file descriptor ID.
 const int kFd = 3;
 
 // Mock connector ID.
 const uint32_t kConnectorId = 1;
 
 // Mock CRTC ID.
 const uint32_t kCrtcId = 1;
 
 // Mock DPMS property ID.
 const uint32_t kDPMSPropertyId = 1;
 
-class MockDrmWrapperOzone : public gfx::DrmWrapperOzone {
+class MockDriWrapper : public gfx::DriWrapper {
  public:
-  MockDrmWrapperOzone() : DrmWrapperOzone(""), id_(1) { fd_ = kFd; }
-  virtual ~MockDrmWrapperOzone() { fd_ = -1; }
+  MockDriWrapper() : DriWrapper(""), id_(1) { 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;
   }
@@ skipping 11 matching lines @@
                         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; }
 
  private:
   int id_;
-  DISALLOW_COPY_AND_ASSIGN(MockDrmWrapperOzone);
+  DISALLOW_COPY_AND_ASSIGN(MockDriWrapper);
 };
 
-class MockDrmSkBitmapOzone : public gfx::DrmSkBitmapOzone {
+class MockDriSkBitmap : public gfx::DriSkBitmap {
  public:
-  MockDrmSkBitmapOzone(int fd,
+  MockDriSkBitmap(int fd,
                        bool initialize_expectation)
-      : DrmSkBitmapOzone(fd),
+      : DriSkBitmap(fd),
         initialize_expectation_(initialize_expectation) {}
-  virtual ~MockDrmSkBitmapOzone() {}
+  virtual ~MockDriSkBitmap() {}
 
   virtual bool Initialize() OVERRIDE {
     if (!initialize_expectation_)
       return false;
 
     allocPixels();
     // Clear the bitmap to black.
     eraseColor(SK_ColorBLACK);
 
     return true;
   }
  private:
   bool initialize_expectation_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockDrmSkBitmapOzone);
+  DISALLOW_COPY_AND_ASSIGN(MockDriSkBitmap);
 };
 
-class MockSoftwareSurfaceOzone : public gfx::SoftwareSurfaceOzone {
+class MockDriSurface : public gfx::DriSurface {
  public:
-  MockSoftwareSurfaceOzone(gfx::HardwareDisplayControllerOzone* controller)
-      : SoftwareSurfaceOzone(controller),
+  MockDriSurface(gfx::HardwareDisplayController* controller)
+      : DriSurface(controller),
         initialize_expectation_(true) {}
-  virtual ~MockSoftwareSurfaceOzone() {}
+  virtual ~MockDriSurface() {}
 
   void set_initialize_expectation(bool state) {
     initialize_expectation_ = state;
   }
 
  private:
-  virtual gfx::DrmSkBitmapOzone* CreateBuffer() OVERRIDE {
-    return new MockDrmSkBitmapOzone(kFd, initialize_expectation_);
+  virtual gfx::DriSkBitmap* CreateBuffer() OVERRIDE {
+    return new MockDriSkBitmap(kFd, initialize_expectation_);
   }
 
   bool initialize_expectation_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockSoftwareSurfaceOzone);
+  DISALLOW_COPY_AND_ASSIGN(MockDriSurface);
 };
 
 }  // namespace
 
-class SoftwareSurfaceOzoneTest : public testing::Test {
+class DriSurfaceTest : public testing::Test {
  public:
-  SoftwareSurfaceOzoneTest() {}
+  DriSurfaceTest() {}
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
  protected:
-  scoped_ptr<MockDrmWrapperOzone> drm_;
-  scoped_ptr<gfx::HardwareDisplayControllerOzone> controller_;
-  scoped_ptr<MockSoftwareSurfaceOzone> surface_;
+  scoped_ptr<MockDriWrapper> drm_;
+  scoped_ptr<gfx::HardwareDisplayController> controller_;
+  scoped_ptr<MockDriSurface> surface_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(SoftwareSurfaceOzoneTest);
+  DISALLOW_COPY_AND_ASSIGN(DriSurfaceTest);
 };
 
-void SoftwareSurfaceOzoneTest::SetUp() {
-  drm_.reset(new MockDrmWrapperOzone());
-  controller_.reset(new gfx::HardwareDisplayControllerOzone());
+void DriSurfaceTest::SetUp() {
+  drm_.reset(new MockDriWrapper());
+  controller_.reset(new gfx::HardwareDisplayController());
   controller_->SetControllerInfo(
       drm_.get(), kConnectorId, kCrtcId, kDPMSPropertyId, kDefaultMode);
 
-  surface_.reset(new MockSoftwareSurfaceOzone(controller_.get()));
+  surface_.reset(new MockDriSurface(controller_.get()));
 }
 
-void SoftwareSurfaceOzoneTest::TearDown() {
+void DriSurfaceTest::TearDown() {
   surface_.reset();
   controller_.reset();
   drm_.reset();
 }
 
-TEST_F(SoftwareSurfaceOzoneTest, FailInitialization) {
+TEST_F(DriSurfaceTest, FailInitialization) {
   surface_->set_initialize_expectation(false);
   EXPECT_FALSE(surface_->Initialize());
 }
 
-TEST_F(SoftwareSurfaceOzoneTest, SuccessfulInitialization) {
+TEST_F(DriSurfaceTest, SuccessfulInitialization) {
   EXPECT_TRUE(surface_->Initialize());
 }
 
-TEST_F(SoftwareSurfaceOzoneTest, CheckFBIDOnSwap) {
+TEST_F(DriSurfaceTest, CheckFBIDOnSwap) {
   EXPECT_TRUE(surface_->Initialize());
   controller_->BindSurfaceToController(
-      surface_.PassAs<gfx::SoftwareSurfaceOzone>());
+      surface_.PassAs<gfx::DriSurface>());
 
   // 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(SoftwareSurfaceOzoneTest, CheckPixelPointerOnSwap) {
+TEST_F(DriSurfaceTest, CheckPixelPointerOnSwap) {
   EXPECT_TRUE(surface_->Initialize());
 
   void* bitmap_pixels1 = surface_->GetDrawableForWidget()->getDevice()
       ->accessBitmap(false).getPixels();
 
   surface_->SwapBuffers();
 
   void* bitmap_pixels2 = surface_->GetDrawableForWidget()->getDevice()
       ->accessBitmap(false).getPixels();
 
   // Check that once the buffers have been swapped the drawable's underlying
   // pixels have been changed.
   EXPECT_NE(bitmap_pixels1, bitmap_pixels2);
 }
 
-TEST_F(SoftwareSurfaceOzoneTest, CheckCorrectBufferSync) {
+TEST_F(DriSurfaceTest, CheckCorrectBufferSync) {
   EXPECT_TRUE(surface_->Initialize());
 
   SkCanvas* canvas = surface_->GetDrawableForWidget();
   SkRect clip;
   // Modify part of the canvas.
   clip.set(0, 0,
            canvas->getDeviceSize().width() / 2,
            canvas->getDeviceSize().height() / 2);
   canvas->clipRect(clip, SkRegion::kReplace_Op);
 
   canvas->drawColor(SK_ColorWHITE);
 
   surface_->SwapBuffers();
 
   // Verify that the modified contents have been copied over on swap (make sure
   // the 2 buffers have the same content).
   for (int i = 0; i < canvas->getDeviceSize().height(); ++i) {
     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));
     }
   }
 }