[Ozone-Dri] Rename DriWrapper to DrmDevice

ui/ozone/platform/dri/gbm_surface.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 "ui/ozone/platform/dri/gbm_surface.h"
 
 #include <gbm.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "ui/ozone/platform/dri/dri_buffer.h"
 #include "ui/ozone/platform/dri/dri_window_delegate.h"
 #include "ui/ozone/platform/dri/gbm_buffer_base.h"
-#include "ui/ozone/platform/dri/gbm_wrapper.h"
+#include "ui/ozone/platform/dri/gbm_device.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
 #include "ui/ozone/platform/dri/scanout_buffer.h"
 
 namespace ui {
 
 namespace {
 
 class GbmSurfaceBuffer : public GbmBufferBase {
  public:
   static scoped_refptr<GbmSurfaceBuffer> CreateBuffer(
-      const scoped_refptr<DriWrapper>& dri,
+      const scoped_refptr<DrmDevice>& drm,
       gbm_bo* buffer);
   static scoped_refptr<GbmSurfaceBuffer> GetBuffer(gbm_bo* buffer);
 
  private:
-  GbmSurfaceBuffer(const scoped_refptr<DriWrapper>& dri, gbm_bo* bo);
+  GbmSurfaceBuffer(const scoped_refptr<DrmDevice>& drm, gbm_bo* bo);
   ~GbmSurfaceBuffer() override;
 
   static void Destroy(gbm_bo* buffer, void* data);
 
   // This buffer is special and is released by GBM at any point in time (as
   // long as it isn't being used). Since GBM should be the only one to
   // release this buffer, keep a self-reference in order to keep this alive.
   // When GBM calls Destroy(..) the self-reference will dissapear and this will
   // be destroyed.
   scoped_refptr<GbmSurfaceBuffer> self_;
 
   DISALLOW_COPY_AND_ASSIGN(GbmSurfaceBuffer);
 };
 
-GbmSurfaceBuffer::GbmSurfaceBuffer(const scoped_refptr<DriWrapper>& dri,
+GbmSurfaceBuffer::GbmSurfaceBuffer(const scoped_refptr<DrmDevice>& drm,
                                    gbm_bo* bo)
-    : GbmBufferBase(dri, bo, true) {
+    : GbmBufferBase(drm, bo, true) {
   if (GetFramebufferId()) {
     self_ = this;
     gbm_bo_set_user_data(bo, this, GbmSurfaceBuffer::Destroy);
   }
 }
 
 GbmSurfaceBuffer::~GbmSurfaceBuffer() {}
 
 // static
 scoped_refptr<GbmSurfaceBuffer> GbmSurfaceBuffer::CreateBuffer(
-    const scoped_refptr<DriWrapper>& dri,
+    const scoped_refptr<DrmDevice>& drm,
     gbm_bo* buffer) {
-  scoped_refptr<GbmSurfaceBuffer> scoped_buffer(new GbmSurfaceBuffer(dri,
-                                                                     buffer));
+  scoped_refptr<GbmSurfaceBuffer> scoped_buffer(
+      new GbmSurfaceBuffer(drm, buffer));
   if (!scoped_buffer->GetFramebufferId())
     return NULL;
 
   return scoped_buffer;
 }
 
 // static
 scoped_refptr<GbmSurfaceBuffer> GbmSurfaceBuffer::GetBuffer(gbm_bo* buffer) {
   return scoped_refptr<GbmSurfaceBuffer>(
       static_cast<GbmSurfaceBuffer*>(gbm_bo_get_user_data(buffer)));
 }
 
 // static
 void GbmSurfaceBuffer::Destroy(gbm_bo* buffer, void* data) {
   GbmSurfaceBuffer* scoped_buffer = static_cast<GbmSurfaceBuffer*>(data);
   scoped_buffer->self_ = NULL;
 }
 
 }  // namespace
 
 GbmSurface::GbmSurface(DriWindowDelegate* window_delegate,
-                       const scoped_refptr<GbmWrapper>& gbm)
+                       const scoped_refptr<GbmDevice>& gbm)
     : GbmSurfaceless(window_delegate, NULL),
       gbm_(gbm),
       native_surface_(NULL),
       current_buffer_(NULL),
       weak_factory_(this) {
 }
 
 GbmSurface::~GbmSurface() {
   if (current_buffer_)
     gbm_surface_release_buffer(native_surface_, current_buffer_);
@@ skipping 72 matching lines @@
                                        gbm_bo* pending_buffer) {
   // If there was a frontbuffer, it is no longer active. Release it back to GBM.
   if (current_buffer_)
     gbm_surface_release_buffer(native_surface_, current_buffer_);
 
   current_buffer_ = pending_buffer;
   callback.Run();
 }
 
 }  // namespace ui