[Ozone-GBM] Pumb DriWindowDelegate throughout the platform

ui/ozone/platform/dri/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/dri/gbm_surface_factory.h"
 
 #include <gbm.h>
 
 #include "base/files/file_path.h"
 #include "third_party/khronos/EGL/egl.h"
+#include "ui/ozone/platform/dri/dri_window_delegate_impl.h"
+#include "ui/ozone/platform/dri/dri_window_manager.h"
 #include "ui/ozone/platform/dri/gbm_buffer.h"
 #include "ui/ozone/platform/dri/gbm_surface.h"
 #include "ui/ozone/platform/dri/gbm_surfaceless.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
 namespace ui {
 
 GbmSurfaceFactory::GbmSurfaceFactory(bool allow_surfaceless)
-    : DriSurfaceFactory(NULL, NULL),
+    : DriSurfaceFactory(NULL, NULL, NULL),
       device_(NULL),
       allow_surfaceless_(allow_surfaceless) {
 }
 
 GbmSurfaceFactory::~GbmSurfaceFactory() {}
 
-void GbmSurfaceFactory::InitializeGpu(
-    DriWrapper* dri, gbm_device* device, ScreenManager* screen_manager) {
+void GbmSurfaceFactory::InitializeGpu(DriWrapper* dri,
+                                      gbm_device* device,
+                                      ScreenManager* screen_manager,
+                                      DriWindowManager* window_manager) {
   drm_ = dri;
   device_ = device;
   screen_manager_ = screen_manager;
+  window_manager_ = window_manager;
 }
 
 intptr_t GbmSurfaceFactory::GetNativeDisplay() {
   DCHECK(state_ == INITIALIZED);
   return reinterpret_cast<intptr_t>(device_);
 }
 
 const int32* GbmSurfaceFactory::GetEGLSurfaceProperties(
     const int32* desired_list) {
   static const int32 kConfigAttribs[] = {
@@ skipping 45 matching lines @@
   set_gl_get_proc_address.Run(get_proc_address);
   add_gl_library.Run(egl_library);
   add_gl_library.Run(gles_library);
 
   return true;
 }
 
 scoped_ptr<SurfaceOzoneEGL> GbmSurfaceFactory::CreateEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
   DCHECK(state_ == INITIALIZED);
+
+  DriWindowDelegate* delegate = GetOrCreateWindowDelegate(widget);
+
   ResetCursor(widget);
 
-  scoped_ptr<GbmSurface> surface(new GbmSurface(
-      screen_manager_->GetDisplayController(widget), device_, drm_));
+  scoped_ptr<GbmSurface> surface(new GbmSurface(delegate, device_, drm_));
   if (!surface->Initialize())
     return scoped_ptr<SurfaceOzoneEGL>();
 
   return surface.PassAs<SurfaceOzoneEGL>();
 }
 
 scoped_ptr<SurfaceOzoneEGL>
 GbmSurfaceFactory::CreateSurfacelessEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
   if (!allow_surfaceless_)
     return scoped_ptr<SurfaceOzoneEGL>();
-  return scoped_ptr<SurfaceOzoneEGL>(
-      new GbmSurfaceless(screen_manager_->GetDisplayController(widget)));
+
+  DriWindowDelegate* delegate = GetOrCreateWindowDelegate(widget);

[alexst (slow to review), 2014/08/20 21:51:09]

I think this leaks. As far as I can tell looking through code, this is a raw
pointer everywhere.

[dnicoara, 2014/08/21 20:54:17]

Arr, yes, I forgot about this through all the refactoring ... I've inverted the
ownership for the sake of simplicity, but this is going to haunt us in the
future.

+  return scoped_ptr<SurfaceOzoneEGL>(new GbmSurfaceless(delegate));
 }
 
 scoped_refptr<ui::NativePixmap> GbmSurfaceFactory::CreateNativePixmap(
     gfx::Size size,
     BufferFormat format) {
   scoped_refptr<GbmBuffer> buffer = GbmBuffer::CreateBuffer(
       drm_, device_, format, size, true);
   if (!buffer)
     return NULL;
 
   return scoped_refptr<GbmPixmap>(new GbmPixmap(buffer));
 }
 
 bool GbmSurfaceFactory::ScheduleOverlayPlane(
     gfx::AcceleratedWidget widget,
     int plane_z_order,
     gfx::OverlayTransform plane_transform,
     scoped_refptr<NativePixmap> buffer,
     const gfx::Rect& display_bounds,
     const gfx::RectF& crop_rect) {
   scoped_refptr<GbmPixmap> pixmap = static_cast<GbmPixmap*>(buffer.get());
   if (!pixmap) {
     LOG(ERROR) << "ScheduleOverlayPlane passed NULL buffer.";
     return false;
   }
-  base::WeakPtr<HardwareDisplayController> hdc =
-      screen_manager_->GetDisplayController(widget);
+  HardwareDisplayController* hdc =
+      window_manager_->GetWindowDelegate(widget)->GetController();
   if (!hdc)
     return true;
+
   hdc->QueueOverlayPlane(OverlayPlane(pixmap->buffer(),
                                       plane_z_order,
                                       plane_transform,
                                       display_bounds,
                                       crop_rect));
   return true;
 }
 
 bool GbmSurfaceFactory::CanShowPrimaryPlaneAsOverlay() {
   return allow_surfaceless_;
 }
 
+DriWindowDelegate* GbmSurfaceFactory::GetOrCreateWindowDelegate(
+    gfx::AcceleratedWidget widget) {
+  if (!window_manager_->HasWindowDelegate(widget)) {
+    DriWindowDelegateImpl* delegate =
+        new DriWindowDelegateImpl(widget, screen_manager_);
+    window_manager_->AddWindowDelegate(widget, delegate);
+    delegate->Initialize();
+    return delegate;
+  }
+
+  return window_manager_->GetWindowDelegate(widget);
+}
+
 }  // namespace ui