Mandoline: Remove native_viewport.mojom

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/connection_manager.h"
+#include "components/view_manager/gles2/gpu_state.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/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/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
@@ skipping 47 matching lines @@
   sqs->opacity = combined_opacity;
   sqs->content_to_target_transform = mojo::Transform::From(node_transform);
 
   pass->quads.push_back(surface_quad.Pass());
   pass->shared_quad_states.push_back(sqs.Pass());
 }
 
 }  // namespace
 
 DefaultDisplayManager::DefaultDisplayManager(
+    bool is_headless,
     mojo::ApplicationImpl* app_impl,
+    const scoped_refptr<gles2::GpuState>& gpu_state,
     const mojo::Callback<void()>& native_viewport_closed_callback)
-    : app_impl_(app_impl),
+    : is_headless_(is_headless),
+      app_impl_(app_impl),
+      gpu_state_(gpu_state),
       connection_manager_(nullptr),
+      event_dispatcher_(nullptr),
       draw_timer_(false, false),
       frame_pending_(false),
       native_viewport_closed_callback_(native_viewport_closed_callback),
       weak_factory_(this) {
-  metrics_.size = mojo::Size::New();
-  metrics_.size->width = 800;
-  metrics_.size->height = 600;
+  metrics_.size_in_pixels = mojo::Size::New();
+  metrics_.size_in_pixels->width = 800;
+  metrics_.size_in_pixels->height = 600;
 }
 
 void DefaultDisplayManager::Init(
     ConnectionManager* connection_manager,
-    mojo::NativeViewportEventDispatcherPtr event_dispatcher) {
+    EventDispatcher* event_dispatcher) {
   connection_manager_ = connection_manager;
-  mojo::URLRequestPtr request(mojo::URLRequest::New());
-  // TODO(beng): should not need to connect to ourselves, should just
-  //             create the appropriate platform window directly.
-  request->url = mojo::String::From("mojo:view_manager");
-  app_impl_->ConnectToService(request.Pass(),
-                              &native_viewport_);
-  native_viewport_.set_error_handler(this);
-  native_viewport_->Create(metrics_.size->Clone(),
-                           base::Bind(&DefaultDisplayManager::OnMetricsChanged,
-                                      weak_factory_.GetWeakPtr()));
+  event_dispatcher_ = event_dispatcher;
+
+  native_viewport_.reset(
+      new NativeViewport(this,
+                         metrics_.size_in_pixels.To<gfx::Size>(),
+                         is_headless_,
+                         gpu_state_));
   native_viewport_->Show();
 
+

[sky, 2015/06/05 23:25:50]

nit: one newline is enough here.

[Fady Samuel, 2015/06/05 23:34:52]

Done.

   mojo::ContextProviderPtr context_provider;
   native_viewport_->GetContextProvider(GetProxy(&context_provider));
   mojo::DisplayFactoryPtr display_factory;
-  mojo::URLRequestPtr request2(mojo::URLRequest::New());
-  request2->url = mojo::String::From("mojo:surfaces_service");
-  app_impl_->ConnectToService(request2.Pass(), &display_factory);
+  mojo::URLRequestPtr request(mojo::URLRequest::New());
+  request->url = mojo::String::From("mojo:surfaces_service");
+  app_impl_->ConnectToService(request.Pass(), &display_factory);
   display_factory->Create(context_provider.Pass(),
                           nullptr,  // returner - we never submit resources.
                           GetProxy(&display_));
-
-  native_viewport_->SetEventDispatcher(event_dispatcher.Pass());
 }
 
 DefaultDisplayManager::~DefaultDisplayManager() {
 }
 
 void DefaultDisplayManager::SchedulePaint(const ServerView* view,
                                           const gfx::Rect& bounds) {
   if (!view->IsDrawn(connection_manager_->root()))
     return;
   const gfx::Rect root_relative_rect =
       ConvertRectBetweenViews(view, connection_manager_->root(), bounds);
   if (root_relative_rect.IsEmpty())
     return;
   dirty_rect_.Union(root_relative_rect);
   WantToDraw();
 }
 
 void DefaultDisplayManager::SetViewportSize(const gfx::Size& size) {
-  native_viewport_->SetSize(Size::From(size));
+  native_viewport_->SetSize(size);
 }
 
 const mojo::ViewportMetrics& DefaultDisplayManager::GetViewportMetrics() {
   return metrics_;
 }
 
 void DefaultDisplayManager::Draw() {
-  gfx::Rect rect(metrics_.size->width, metrics_.size->height);
+  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(), connection_manager_->root(), gfx::Vector2d(), 1.0f);
 
   auto frame = mojo::Frame::New();
   frame->passes.push_back(pass.Pass());
   frame->resources.resize(0u);
   frame_pending_ = true;
   display_->SubmitFrame(
@@ skipping 10 matching lines @@
 
 void DefaultDisplayManager::WantToDraw() {
   if (draw_timer_.IsRunning() || frame_pending_)
     return;
 
   draw_timer_.Start(
       FROM_HERE, base::TimeDelta(),
       base::Bind(&DefaultDisplayManager::Draw, base::Unretained(this)));
 }
 
-void DefaultDisplayManager::OnMetricsChanged(mojo::ViewportMetricsPtr metrics) {
-  metrics_.size = metrics->size.Clone();
-  metrics_.device_pixel_ratio = metrics->device_pixel_ratio;
-  gfx::Rect bounds(metrics_.size.To<gfx::Size>());
-  connection_manager_->root()->SetBounds(bounds);
-  connection_manager_->ProcessViewportMetricsChanged(metrics_, *metrics);
-  native_viewport_->RequestMetrics(base::Bind(
-      &DefaultDisplayManager::OnMetricsChanged, weak_factory_.GetWeakPtr()));
+bool DefaultDisplayManager::OnEvent(mojo::EventPtr event) {
+  if (!event_dispatcher_)

[sky, 2015/06/05 23:25:50]

Do we ever pass in null?

[Fady Samuel, 2015/06/05 23:34:52]

No, removed the check.

+    return false;
+
+  event_dispatcher_->OnEvent(event.Pass());
+  return false;
 }
 
-void DefaultDisplayManager::OnConnectionError() {
-  // This is called when the native_viewport is torn down before
-  // ~DefaultDisplayManager may be called.
-  native_viewport_closed_callback_.Run();
+void DefaultDisplayManager::OnMetricsChanged(const gfx::Size& size,
+                                             float device_scale_factor) {

[sky, 2015/06/05 23:25:50]

It seems like we may get here and the metrics haven't changed. Since this class
caches them could you early out if they haven't changed? Or as NativeViewport
does some caching make it cache it all and only invoke when truly changed.

[Fady Samuel, 2015/06/05 23:34:52]

Done.

+  mojo::ViewportMetrics metrics;
+  metrics.size_in_pixels = mojo::Size::From(size);
+  metrics.device_pixel_ratio = device_scale_factor;
+
+  connection_manager_->root()->SetBounds(gfx::Rect(size));
+  connection_manager_->ProcessViewportMetricsChanged(metrics_, metrics);
+
+  metrics_.size_in_pixels = metrics.size_in_pixels.Clone();
+  metrics_.device_pixel_ratio = metrics.device_pixel_ratio;
+}
+
+void DefaultDisplayManager::OnViewDestroyed() {
+  if (!native_viewport_closed_callback_.is_null())
+    native_viewport_closed_callback_.Run();
 }
 
 }  // namespace view_manager