Rename OzonePlatformGbm::drm_thread_ to OzonePlatformGbm::drm_thread_proxy_

ui/ozone/platform/drm/ozone_platform_gbm.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/ozone_platform_gbm.h"
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <stdlib.h>
@@ skipping 95 matching lines @@
   }
   std::unique_ptr<SystemInputInjector> CreateSystemInputInjector() override {
     return event_factory_ozone_->CreateSystemInputInjector();
   }
   void AddInterfaces(shell::InterfaceRegistry* registry) override {
     registry->AddInterface<ozone::mojom::DeviceCursor>(this);
   }
   // shell::InterfaceFactory<mojom::ozone::Cursor> implementation.
   void Create(const shell::Identity& remote_identity,
               ozone::mojom::DeviceCursorRequest request) override {
-    DCHECK(drm_thread_);
-    drm_thread_->AddBinding(std::move(request));
+    DCHECK(drm_thread_proxy_);
+    drm_thread_proxy_->AddBinding(std::move(request));
   }
   std::unique_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
       const gfx::Rect& bounds) override {
     GpuThreadAdapter* adapter = gpu_platform_support_host_.get();
     if (using_mojo_ || single_process_) {
-      DCHECK(drm_thread_) << "drm_thread_ should exist (and be running) here.";
+      DCHECK(drm_thread_proxy_)
+          << "drm_thread_proxy_ should exist (and be running) here.";
       adapter = mus_thread_proxy_.get();
     }
 
     std::unique_ptr<DrmWindowHost> platform_window(new DrmWindowHost(
         delegate, bounds, adapter, event_factory_ozone_.get(), cursor_.get(),
         window_manager_.get(), display_manager_.get(), overlay_manager_.get()));
     platform_window->Initialize();
     return std::move(platform_window);
   }
   std::unique_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate()
@@ skipping 85 matching lines @@
     } else {
       gl_api_loader_.reset(new GlApiLoader());
       scoped_refptr<DrmThreadMessageProxy> message_proxy(
           new DrmThreadMessageProxy());
       itmp = message_proxy.get();
       gpu_message_filter_ = std::move(message_proxy);
     }
 
     // NOTE: Can't start the thread here since this is called before sandbox
     // initialization in multi-process Chrome. In mus, we start the DRM thread.
-    drm_thread_.reset(new DrmThreadProxy());
-    drm_thread_->BindThreadIntoMessagingProxy(itmp);
+    drm_thread_proxy_.reset(new DrmThreadProxy());
+    drm_thread_proxy_->BindThreadIntoMessagingProxy(itmp);
 
-    surface_factory_.reset(new GbmSurfaceFactory(drm_thread_.get()));
+    surface_factory_.reset(new GbmSurfaceFactory(drm_thread_proxy_.get()));
     if (using_mojo_ || single_process_) {
       mus_thread_proxy_->StartDrmThread();
     }
   }
 
  private:
   bool using_mojo_;
   bool single_process_;
 
   // Objects in the GPU process.
-  // TODO(rjk): rename drm_thread_ to drm_thread_proxy_;
-  std::unique_ptr<DrmThreadProxy> drm_thread_;
+  std::unique_ptr<DrmThreadProxy> drm_thread_proxy_;
   std::unique_ptr<GlApiLoader> gl_api_loader_;
   std::unique_ptr<GbmSurfaceFactory> surface_factory_;
   scoped_refptr<IPC::MessageFilter> gpu_message_filter_;
 
   // Objects in the Browser process.
   std::unique_ptr<DeviceManager> device_manager_;
   std::unique_ptr<BitmapCursorFactoryOzone> cursor_factory_ozone_;
   std::unique_ptr<DrmWindowHostManager> window_manager_;
   std::unique_ptr<DrmCursor> cursor_;
   std::unique_ptr<EventFactoryEvdev> event_factory_ozone_;
@@ skipping 11 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(OzonePlatformGbm);
 };
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformGbm() {
   return new OzonePlatformGbm;
 }
 
 }  // namespace ui