Mandoline: Merge Surfaces and Views apps

components/view_manager/display_manager.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 "components/view_manager/display_manager.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "components/view_manager/display_manager_factory.h"
 #include "components/view_manager/gles2/gpu_state.h"
-#include "components/view_manager/native_viewport/onscreen_context_provider.h"
 #include "components/view_manager/public/interfaces/gpu.mojom.h"
 #include "components/view_manager/public/interfaces/quads.mojom.h"
 #include "components/view_manager/public/interfaces/surfaces.mojom.h"
 #include "components/view_manager/server_view.h"
+#include "components/view_manager/surfaces/surfaces_state.h"
 #include "components/view_manager/view_coordinate_conversions.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/input_events/mojo_extended_key_event_data.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
 #include "mojo/converters/transform/transform_type_converters.h"
 #include "ui/events/event.h"
@@ skipping 73 matching lines @@
 
 }  // namespace
 
 // static
 DisplayManagerFactory* DisplayManager::factory_ = nullptr;
 
 // static
 DisplayManager* DisplayManager::Create(
     bool is_headless,
     mojo::ApplicationImpl* app_impl,
-    const scoped_refptr<gles2::GpuState>& gpu_state) {
-  if (factory_)
-    return factory_->CreateDisplayManager(is_headless, app_impl, gpu_state);
-  return new DefaultDisplayManager(is_headless, app_impl, gpu_state);
+    const scoped_refptr<gles2::GpuState>& gpu_state,
+    const scoped_refptr<surfaces::SurfacesState>& surfaces_state) {
+  if (factory_) {
+    return factory_->CreateDisplayManager(is_headless, app_impl, gpu_state,
+                                          surfaces_state);
+  }
+  return new DefaultDisplayManager(is_headless, app_impl, gpu_state,
+                                   surfaces_state);
 }
 
 DefaultDisplayManager::DefaultDisplayManager(
     bool is_headless,
     mojo::ApplicationImpl* app_impl,
-    const scoped_refptr<gles2::GpuState>& gpu_state)
+    const scoped_refptr<gles2::GpuState>& gpu_state,
+    const scoped_refptr<surfaces::SurfacesState>& surfaces_state)
     : is_headless_(is_headless),
       app_impl_(app_impl),
       gpu_state_(gpu_state),
+      surfaces_state_(surfaces_state),
       delegate_(nullptr),
       draw_timer_(false, false),
-      frame_pending_(false),
-      context_provider_(
-          new native_viewport::OnscreenContextProvider(gpu_state)),
-      weak_factory_(this) {
+      frame_pending_(false) {
   metrics_.size_in_pixels = mojo::Size::New();
   metrics_.size_in_pixels->width = 800;
   metrics_.size_in_pixels->height = 600;
 }
 
 void DefaultDisplayManager::Init(DisplayManagerDelegate* delegate) {
   delegate_ = delegate;
 
   gfx::Rect bounds(metrics_.size_in_pixels.To<gfx::Size>());
   if (is_headless_) {
     platform_window_.reset(new ui::StubWindow(this));
   } else {
 #if defined(OS_WIN)
     platform_window_.reset(new ui::WinWindow(this, bounds));
 #elif defined(USE_X11)
     platform_window_.reset(new ui::X11Window(this));
 #elif defined(OS_ANDROID)
     platform_window_.reset(new ui::PlatformWindowAndroid(this));
 #else
     NOTREACHED() << "Unsupported platform";
 #endif
   }
   platform_window_->SetBounds(bounds);
   platform_window_->Show();
-
-  mojo::ContextProviderPtr context_provider;
-  context_provider_->Bind(GetProxy(&context_provider).Pass());
-  mojo::DisplayFactoryPtr display_factory;
-  mojo::URLRequestPtr request(mojo::URLRequest::New());
-  request->url = mojo::String::From("mojo:surfaces_service");
-  app_impl_->ConnectToService(request.Pass(), &display_factory);
-  // TODO(fsamuel): We should indicate to the delegate that this object failed
-  // to initialize.
-  if (!display_factory)
-    return;
-  display_factory->Create(context_provider.Pass(),
-                          nullptr,  // returner - we never submit resources.
-                          GetProxy(&display_));
 }
 
 DefaultDisplayManager::~DefaultDisplayManager() {
-  // Destroy before |platform_window_| because this will destroy
-  // CommandBufferDriver objects that contain child windows. Otherwise if this
-  // class destroys its window first, X errors will occur.
-  context_provider_.reset();
-
   // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state.
   platform_window_.reset();
 }
 
 void DefaultDisplayManager::SchedulePaint(const ServerView* view,
                                           const gfx::Rect& bounds) {
   DCHECK(view);
   if (!view->IsDrawn())
     return;
@@ skipping 32 matching lines @@
   gfx::Rect rect(metrics_.size_in_pixels.To<gfx::Size>());
   auto pass = mojo::CreateDefaultPass(1, rect);
   pass->damage_rect = Rect::From(dirty_rect_);
 
   DrawViewTree(pass.get(), delegate_->GetRootView(), gfx::Vector2d(), 1.0f);
 
   auto frame = mojo::Frame::New();
   frame->passes.push_back(pass.Pass());
   frame->resources.resize(0u);
   frame_pending_ = true;
-  if (display_) {
-    display_->SubmitFrame(frame.Pass(),
-                          base::Bind(&DefaultDisplayManager::DidDraw,
-                                     weak_factory_.GetWeakPtr()));
+  if (top_level_display_client_) {
+    top_level_display_client_->SubmitFrame(
+        frame.Pass(),
+        base::Bind(&DefaultDisplayManager::DidDraw, base::Unretained(this)));
   }
   dirty_rect_ = gfx::Rect();
 }
 
 void DefaultDisplayManager::DidDraw() {
   frame_pending_ = false;
   if (!dirty_rect_.IsEmpty())
     WantToDraw();
 }
 
@@ skipping 101 matching lines @@
 void DefaultDisplayManager::OnWindowStateChanged(
     ui::PlatformWindowState new_state) {
 }
 
 void DefaultDisplayManager::OnLostCapture() {
 }
 
 void DefaultDisplayManager::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_pixel_ratio) {
-  context_provider_->SetAcceleratedWidget(widget);
+  if (widget != gfx::kNullAcceleratedWidget) {
+    top_level_display_client_.reset(new surfaces::TopLevelDisplayClient(
+        widget, gpu_state_, surfaces_state_));
+  }
   UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
 }
 
 void DefaultDisplayManager::OnActivationChanged(bool active) {
 }
 
 }  // namespace view_manager