ozone: Add OzoneSurface object that is owned by compositor, GLSurface

ui/aura/window_tree_host_ozone.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 "ui/aura/window_tree_host_ozone.h"
 
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/cursor/ozone/cursor_factory_ozone.h"
 #include "ui/events/ozone/event_factory_ozone.h"
 #include "ui/gfx/ozone/surface_factory_ozone.h"
 #include "ui/ozone/ozone_platform.h"
 
 namespace aura {
 
 WindowTreeHostOzone::WindowTreeHostOzone(const gfx::Rect& bounds)
     : widget_(0),
       bounds_(bounds) {
   ui::OzonePlatform::Initialize();
 
   // EventFactoryOzone creates converters that obtain input events from the
   // underlying input system and dispatch them as |ui::Event| instances into
   // Aura.
   ui::EventFactoryOzone::GetInstance()->StartProcessingEvents();
 
   gfx::SurfaceFactoryOzone* surface_factory =
       gfx::SurfaceFactoryOzone::GetInstance();
   widget_ = surface_factory->GetAcceleratedWidget();
 
-  surface_factory->AttemptToResizeAcceleratedWidget(widget_, bounds_);

[rjkroege, 2014/03/24 16:07:04]

I see that this change is necessary to compile but will the SurfaceOzone end up
being resized correctly without a different replacement?

[spang, 2014/03/24 16:42:11]

This is redundant. The surface gets its size from the compositor size, and the
compositor is initialized from the window bounds inside
WindowTreeHost::InitCompositor().

WindowTreeHostOzone should not concern itself with the surface, only the window.

[rjkroege, 2014/03/24 20:23:15]

in implementations where it matters, how does the widget get its size?

[spang, 2014/03/24 21:58:28]

Sizing upon initialization goes this way:

  1. Window is created with an initial bounds. This sets the initial size in the
windowing system (future: WindowFactoryOzone::CreateWindow). 
  2. WindowTreeHost calls GetBounds(), which gets the current bounds from the
windowing system, and uses that value to initialize the compositor
(Compositor::SetScaleAndSize).
  3. The compositor plumbs the size down into SoftwareOutputDeviceOzone.
  4. SoftwareOutputDeviceOzone calls AttemptToResizeAcceleratedWidget

That's what I meant when I said this was redundant. The same call already
happens via another path.

Let's let the compositor drive the surface sizing and not worry about it from
WindowTreeHost.

-
   base::MessagePumpOzone::Current()->AddDispatcherForRootWindow(this);
   CreateCompositor(GetAcceleratedWidget());
 }
 
 WindowTreeHostOzone::~WindowTreeHostOzone() {
   base::MessagePumpOzone::Current()->RemoveDispatcherForRootWindow(0);
   DestroyCompositor();
   DestroyDispatcher();
 }
 
@@ skipping 80 matching lines @@
   return new WindowTreeHostOzone(bounds);
 }
 
 // static
 gfx::Size WindowTreeHost::GetNativeScreenSize() {
   NOTIMPLEMENTED();
   return gfx::Size();
 }
 
 }  // namespace aura