Rename GbmSurfaceFactory::drm_thread_ to GbmSurfaceFactory::drm_thread_proxy_

ui/ozone/platform/drm/gpu/gbm_surface_factory.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/drm/gpu/gbm_surface_factory.h"
 
 #include <gbm.h>
 
 #include <utility>
 
@@ skipping 15 matching lines @@
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 
 namespace ui {
 
 namespace {
 
 class GLOzoneEGLGbm : public GLOzoneEGL {
  public:
-  GLOzoneEGLGbm(GbmSurfaceFactory* surface_factory, DrmThreadProxy* drm_thread)
-      : surface_factory_(surface_factory), drm_thread_(drm_thread) {}
+  GLOzoneEGLGbm(GbmSurfaceFactory* surface_factory,
+                DrmThreadProxy* drm_thread_proxy)
+      : surface_factory_(surface_factory),
+        drm_thread_proxy_(drm_thread_proxy) {}
   ~GLOzoneEGLGbm() override {}
 
   scoped_refptr<gl::GLSurface> CreateViewGLSurface(
       gfx::AcceleratedWidget window) override {
     return gl::InitializeGLSurface(new GbmSurface(
-        surface_factory_, drm_thread_->CreateDrmWindowProxy(window), window));
+        surface_factory_, drm_thread_proxy_->CreateDrmWindowProxy(window),
+        window));
   }
 
   scoped_refptr<gl::GLSurface> CreateSurfacelessViewGLSurface(
       gfx::AcceleratedWidget window) override {
     return gl::InitializeGLSurface(new GbmSurfaceless(
-        surface_factory_, drm_thread_->CreateDrmWindowProxy(window), window));
+        surface_factory_, drm_thread_proxy_->CreateDrmWindowProxy(window),
+        window));
   }
 
   scoped_refptr<gl::GLSurface> CreateOffscreenGLSurface(
       const gfx::Size& size) override {
     DCHECK_EQ(size.width(), 0);
     DCHECK_EQ(size.height(), 0);
     return gl::InitializeGLSurface(new gl::SurfacelessEGL(size));
   }
 
  protected:
   intptr_t GetNativeDisplay() override { return EGL_DEFAULT_DISPLAY; }
 
   bool LoadGLES2Bindings() override { return LoadDefaultEGLGLES2Bindings(); }
 
  private:
   GbmSurfaceFactory* surface_factory_;
-  DrmThreadProxy* drm_thread_;
+  DrmThreadProxy* drm_thread_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(GLOzoneEGLGbm);
 };
 
 }  // namespace
 
-GbmSurfaceFactory::GbmSurfaceFactory(DrmThreadProxy* drm_thread)
-    : egl_implementation_(new GLOzoneEGLGbm(this, drm_thread)),
-      drm_thread_(drm_thread) {}
+GbmSurfaceFactory::GbmSurfaceFactory(DrmThreadProxy* drm_thread_proxy)
+    : egl_implementation_(new GLOzoneEGLGbm(this, drm_thread_proxy)),
+      drm_thread_proxy_(drm_thread_proxy) {}
 
 GbmSurfaceFactory::~GbmSurfaceFactory() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void GbmSurfaceFactory::RegisterSurface(gfx::AcceleratedWidget widget,
                                         GbmSurfaceless* surface) {
   DCHECK(thread_checker_.CalledOnValidThread());
   widget_to_surface_map_.insert(std::make_pair(widget, surface));
 }
@@ skipping 33 matching lines @@
 std::unique_ptr<SurfaceOzoneCanvas> GbmSurfaceFactory::CreateCanvasForWidget(
     gfx::AcceleratedWidget widget) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG(ERROR) << "Software rendering mode is not supported with GBM platform";
   return nullptr;
 }
 
 std::vector<gfx::BufferFormat> GbmSurfaceFactory::GetScanoutFormats(
     gfx::AcceleratedWidget widget) {
   std::vector<gfx::BufferFormat> scanout_formats;
-  drm_thread_->GetScanoutFormats(widget, &scanout_formats);
+  drm_thread_proxy_->GetScanoutFormats(widget, &scanout_formats);
   return scanout_formats;
 }
 
 scoped_refptr<ui::NativePixmap> GbmSurfaceFactory::CreateNativePixmap(
     gfx::AcceleratedWidget widget,
     gfx::Size size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
 #if !defined(OS_CHROMEOS)
   // Support for memory mapping accelerated buffers requires some
   // CrOS-specific patches (using dma-buf mmap API).
   DCHECK(gfx::BufferUsage::SCANOUT == usage);
 #endif
 
   scoped_refptr<GbmBuffer> buffer =
-      drm_thread_->CreateBuffer(widget, size, format, usage);
+      drm_thread_proxy_->CreateBuffer(widget, size, format, usage);
   if (!buffer.get())
     return nullptr;
 
   return make_scoped_refptr(new GbmPixmap(this, buffer));
 }
 
 scoped_refptr<ui::NativePixmap> GbmSurfaceFactory::CreateNativePixmapFromHandle(
     gfx::AcceleratedWidget widget,
     gfx::Size size,
     gfx::BufferFormat format,
     const gfx::NativePixmapHandle& handle) {
   size_t num_planes = gfx::NumberOfPlanesForBufferFormat(format);
   if (handle.planes.size() != num_planes ||
       (handle.fds.size() != 1 && handle.fds.size() != num_planes)) {
     return nullptr;
   }
   std::vector<base::ScopedFD> scoped_fds;
   for (auto& fd : handle.fds) {
     scoped_fds.emplace_back(fd.fd);
   }
 
   std::vector<gfx::NativePixmapPlane> planes;
 
   for (const auto& plane : handle.planes) {
     planes.push_back(plane);
   }
 
-  scoped_refptr<GbmBuffer> buffer = drm_thread_->CreateBufferFromFds(
+  scoped_refptr<GbmBuffer> buffer = drm_thread_proxy_->CreateBufferFromFds(
       widget, size, format, std::move(scoped_fds), planes);
   if (!buffer)
     return nullptr;
   return make_scoped_refptr(new GbmPixmap(this, buffer));
 }
 
 }  // namespace ui