view-manager: Create the root-view only when the viewport-metrics are known.

Instead of creating the root-view at first, delay the creation until the viewport
metrics are known. This avoids having to create the root-view with a default size,
and then updating the size when the viewport metrics become known.

With this change, a Browser knows about the device-pixel ratio as soon as it is
embedded. So there's no more need for DevicePixelRatioWaiter. So that is also
removed.

BUG=496935

Review URL: https://codereview.chromium.org/1229893004

Cr-Commit-Position: refs/heads/master@{#338905}

7 files changed, 73 insertions, 51 deletions

diff --git a/components/view_manager/display_manager.cc b/components/view_manager/display_manager.cc
index 373ff57..cf3f113 100644
--- a/components/view_manager/display_manager.cc
+++ b/components/view_manager/display_manager.cc
@@ -234,15 +234,14 @@ void DefaultDisplayManager::UpdateMetrics(const gfx::Size& size,
   if (metrics_.size_in_pixels.To<gfx::Size>() == size &&
       metrics_.device_pixel_ratio == device_pixel_ratio)
     return;
-  mojo::ViewportMetrics metrics;
-  metrics.size_in_pixels = mojo::Size::From(size);
-  metrics.device_pixel_ratio = device_pixel_ratio;
+  mojo::ViewportMetrics old_metrics;
+  old_metrics.size_in_pixels = metrics_.size_in_pixels.Clone();
+  old_metrics.device_pixel_ratio = metrics_.device_pixel_ratio;
 
-  delegate_->GetRootView()->SetBounds(gfx::Rect(size));
-  delegate_->OnViewportMetricsChanged(metrics_, metrics);
+  metrics_.size_in_pixels = mojo::Size::From(size);
+  metrics_.device_pixel_ratio = device_pixel_ratio;
 
-  metrics_.size_in_pixels = metrics.size_in_pixels.Clone();
-  metrics_.device_pixel_ratio = metrics.device_pixel_ratio;
+  delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
 void DefaultDisplayManager::OnBoundsChanged(const gfx::Rect& new_bounds) {
diff --git a/components/view_manager/view_manager_app.cc b/components/view_manager/view_manager_app.cc
index 6cbed25..1f9f283 100644
--- a/components/view_manager/view_manager_app.cc
+++ b/components/view_manager/view_manager_app.cc
@@ -100,21 +100,16 @@ void ViewManagerApp::Create(ApplicationConnection* connection,
   DCHECK(connection_manager_.get());
   // TODO(fsamuel): We need to make sure that only the window manager can create
   // new roots.
-  scoped_ptr<ViewManagerRootImpl> view_manager_root(
-      new ViewManagerRootImpl(
-          connection_manager_.get(),
-          is_headless_,
-          app_impl_,
-          gpu_state_));
+  ViewManagerRootImpl* view_manager_root = new ViewManagerRootImpl(
+      connection_manager_.get(), is_headless_, app_impl_, gpu_state_);
 
   mojo::ViewManagerClientPtr client;
   connection->ConnectToService(&client);
 
   // ViewManagerRootConnection manages its own lifetime.
-  new ViewManagerRootConnectionImpl(request.Pass(),
-                                    view_manager_root.Pass(),
-                                    client.Pass(),
-                                    connection_manager_.get());
+  view_manager_root->Init(new ViewManagerRootConnectionImpl(
+      request.Pass(), make_scoped_ptr(view_manager_root), client.Pass(),
+      connection_manager_.get()));
 }
 
 void ViewManagerApp::Create(
diff --git a/components/view_manager/view_manager_root_connection.cc b/components/view_manager/view_manager_root_connection.cc
index 18e7f29..017ccbe 100644
--- a/components/view_manager/view_manager_root_connection.cc
+++ b/components/view_manager/view_manager_root_connection.cc
@@ -16,7 +16,6 @@ ViewManagerRootConnection::ViewManagerRootConnection(
       service_(nullptr),
       connection_manager_(manager),
       connection_closed_(false) {
-  root_->Init(this);
 }
 
 ViewManagerRootConnection::~ViewManagerRootConnection() {
@@ -40,6 +39,9 @@ ViewManagerServiceImpl* ViewManagerRootConnection::GetViewManagerService() {
   return service_;
 }
 
+void ViewManagerRootConnection::OnDisplayInitialized() {
+}
+
 void ViewManagerRootConnection::OnDisplayClosed() {
   CloseConnection();
 }
@@ -50,17 +52,18 @@ ViewManagerRootConnectionImpl::ViewManagerRootConnectionImpl(
     mojo::ViewManagerClientPtr client,
     ConnectionManager* manager)
     : ViewManagerRootConnection(root.Pass(), manager),
-      binding_(view_manager_root(), request.Pass()) {
-  binding_.set_connection_error_handler([this]() { CloseConnection(); });
-
-  connection_manager()->AddRoot(this);
-  set_view_manager_service(connection_manager()->EmbedAtView(
-      kInvalidConnectionId,
-      view_manager_root()->root_view()->id(),
-      client.Pass()));
+      binding_(view_manager_root(), request.Pass()),
+      client_(client.Pass()) {
 }
 
 ViewManagerRootConnectionImpl::~ViewManagerRootConnectionImpl() {
 }
 
+void ViewManagerRootConnectionImpl::OnDisplayInitialized() {
+  connection_manager()->AddRoot(this);
+  set_view_manager_service(connection_manager()->EmbedAtView(
+      kInvalidConnectionId, view_manager_root()->root_view()->id(),
+      client_.Pass()));
+}
+
 }  // namespace view_manager
diff --git a/components/view_manager/view_manager_root_connection.h b/components/view_manager/view_manager_root_connection.h
index 4d1d8b3..cc89c22 100644
--- a/components/view_manager/view_manager_root_connection.h
+++ b/components/view_manager/view_manager_root_connection.h
@@ -46,11 +46,12 @@ class ViewManagerRootConnection : public ViewManagerRootDelegate {
  protected:
   ~ViewManagerRootConnection() override;
 
- private:
   // ViewManagerRootDelegate:
-  ViewManagerServiceImpl* GetViewManagerService() override;
+  void OnDisplayInitialized() override;
   void OnDisplayClosed() override;
+  ViewManagerServiceImpl* GetViewManagerService() override;
 
+ private:
   scoped_ptr<ViewManagerRootImpl> root_;
   ViewManagerServiceImpl* service_;
   ConnectionManager* connection_manager_;
@@ -71,7 +72,11 @@ class ViewManagerRootConnectionImpl : public ViewManagerRootConnection {
  private:
   ~ViewManagerRootConnectionImpl() override;
 
+  // ViewManagerRootDelegate:
+  void OnDisplayInitialized() override;
+
   mojo::Binding<mojo::ViewManagerRoot> binding_;
+  mojo::ViewManagerClientPtr client_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerRootConnectionImpl);
 };
diff --git a/components/view_manager/view_manager_root_delegate.h b/components/view_manager/view_manager_root_delegate.h
index 3984bd6..b85440c 100644
--- a/components/view_manager/view_manager_root_delegate.h
+++ b/components/view_manager/view_manager_root_delegate.h
@@ -17,6 +17,10 @@ class ViewManagerServiceImpl;
 // when the Display of the root is closed.
 class ViewManagerRootDelegate {
  public:
+  // Called when the window associated with the root is completely initialized
+  // (i.e. the ViewportMetrics for the display is known).
+  virtual void OnDisplayInitialized() = 0;
+
   // Called when the window associated with the root is closed.
   virtual void OnDisplayClosed() = 0;
 
diff --git a/components/view_manager/view_manager_root_impl.cc b/components/view_manager/view_manager_root_impl.cc
index 6301ebf..00dc133 100644
--- a/components/view_manager/view_manager_root_impl.cc
+++ b/components/view_manager/view_manager_root_impl.cc
@@ -19,12 +19,8 @@ ViewManagerRootImpl::ViewManagerRootImpl(
     const scoped_refptr<gles2::GpuState>& gpu_state)
     : delegate_(nullptr),
       connection_manager_(connection_manager),
-      root_(connection_manager->CreateServerView(
-         RootViewId(connection_manager->GetAndAdvanceNextRootId()))),
       display_manager_(
           DisplayManager::Create(is_headless, app_impl, gpu_state)) {
-  root_->SetBounds(gfx::Rect(800, 600));
-  root_->SetVisible(true);
   display_manager_->Init(this);
 }
 
@@ -33,6 +29,8 @@ ViewManagerRootImpl::~ViewManagerRootImpl() {
 
 void ViewManagerRootImpl::Init(ViewManagerRootDelegate* delegate) {
   delegate_ = delegate;
+  if (delegate_ && root_)
+    delegate_->OnDisplayInitialized();
 }
 
 ViewManagerServiceImpl* ViewManagerRootImpl::GetViewManagerService() {
@@ -96,8 +94,18 @@ void ViewManagerRootImpl::OnDisplayClosed() {
 void ViewManagerRootImpl::OnViewportMetricsChanged(
     const mojo::ViewportMetrics& old_metrics,
     const mojo::ViewportMetrics& new_metrics) {
-  // TODO(fsamuel: We shouldn't broadcast this to all connections but only those
-  // within a window root.
+  if (!root_) {
+    root_.reset(connection_manager_->CreateServerView(
+        RootViewId(connection_manager_->GetAndAdvanceNextRootId())));
+    root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
+    root_->SetVisible(true);
+    if (delegate_)
+      delegate_->OnDisplayInitialized();
+  } else {
+    root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
+  }
+  // TODO(fsamuel): We shouldn't broadcast this to all connections but only
+  // those within a window root.
   connection_manager_->ProcessViewportMetricsChanged(old_metrics, new_metrics);
 }
 
diff --git a/components/view_manager/view_manager_service_unittest.cc b/components/view_manager/view_manager_service_unittest.cc
index d3701ad..72a986a 100644
--- a/components/view_manager/view_manager_service_unittest.cc
+++ b/components/view_manager/view_manager_service_unittest.cc
@@ -117,11 +117,12 @@ class TestClientConnection : public ClientConnection {
  public:
   explicit TestClientConnection(scoped_ptr<ViewManagerServiceImpl> service_impl)
       : ClientConnection(service_impl.Pass(), &client_) {}
-  ~TestClientConnection() override {}
 
   TestViewManagerClient* client() { return &client_; }
 
  private:
+  ~TestClientConnection() override {}
+
   TestViewManagerClient client_;
 
   DISALLOW_COPY_AND_ASSIGN(TestClientConnection);
@@ -178,19 +179,20 @@ class TestConnectionManagerDelegate : public ConnectionManagerDelegate {
 
 class TestViewManagerRootConnection : public ViewManagerRootConnection {
  public:
-  TestViewManagerRootConnection(
-      scoped_ptr<ViewManagerRootImpl> root,
-      ConnectionManager* manager)
-      : ViewManagerRootConnection(root.Pass(), manager) {
+  TestViewManagerRootConnection(scoped_ptr<ViewManagerRootImpl> root,
+                                ConnectionManager* manager)
+      : ViewManagerRootConnection(root.Pass(), manager) {}
+  ~TestViewManagerRootConnection() override {}
+
+ private:
+  // ViewManagerRootDelegate:
+  void OnDisplayInitialized() override {
     connection_manager()->AddRoot(this);
     set_view_manager_service(connection_manager()->EmbedAtView(
         kInvalidConnectionId,
         view_manager_root()->root_view()->id(),
         mojo::ViewManagerClientPtr()));
   }
-  ~TestViewManagerRootConnection() override {}
-
- private:
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerRootConnection);
 };
 
@@ -202,7 +204,15 @@ class TestDisplayManager : public DisplayManager {
   ~TestDisplayManager() override {}
 
   // DisplayManager:
-  void Init(DisplayManagerDelegate* delegate) override {}
+  void Init(DisplayManagerDelegate* delegate) override {
+    // It is necessary to tell the delegate about the ViewportMetrics to make
+    // sure that the ViewManagerRootConnection is correctly initialized (and a
+    // root-view is created).
+    mojo::ViewportMetrics metrics;
+    metrics.size_in_pixels = mojo::Size::From(gfx::Size(400, 300));
+    metrics.device_pixel_ratio = 1.f;
+    delegate->OnViewportMetricsChanged(mojo::ViewportMetrics(), metrics);
+  }
   void SchedulePaint(const ServerView* view, const gfx::Rect& bounds) override {
   }
   void SetViewportSize(const gfx::Size& size) override {}
@@ -286,16 +296,14 @@ class ViewManagerServiceTest : public testing::Test {
     DisplayManager::set_factory_for_testing(&display_manager_factory_);
     // TODO(fsamuel): This is probably broken. We need a root.
     connection_manager_.reset(new ConnectionManager(&delegate_));
-    scoped_ptr<ViewManagerRootImpl> root(
-        new ViewManagerRootImpl(connection_manager_.get(),
-                                true /* is_headless */,
-                                nullptr,
-                                scoped_refptr<gles2::GpuState>()));
+    ViewManagerRootImpl* root = new ViewManagerRootImpl(
+        connection_manager_.get(), true /* is_headless */, nullptr,
+        scoped_refptr<gles2::GpuState>());
     // TODO(fsamuel): This is way too magical. We need to find a better way to
     // manage lifetime.
-    root_connection_ =
-        new TestViewManagerRootConnection(root.Pass(),
-                                          connection_manager_.get());
+    root_connection_ = new TestViewManagerRootConnection(
+        make_scoped_ptr(root), connection_manager_.get());
+    root->Init(root_connection_);
     wm_client_ = delegate_.last_client();
   }