mojo: Fix window resizing in mojo_sample_app and mojo_demo_launcher.

mojo/services/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 "mojo/services/view_manager/display_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/scoped_observer.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/services/public/interfaces/gpu/gpu.mojom.h"
@@ skipping 39 matching lines @@
   for (size_t i = 0; i < children.size(); ++i) {
     PaintViewTree(
         canvas, children[i], origin + children[i]->bounds().OffsetFromOrigin());
   }
 }
 
 }  // namespace
 
 class DisplayManager::RootWindowDelegateImpl : public aura::WindowDelegate {
  public:
-  explicit RootWindowDelegateImpl(const ServerView* root_view)
-      : root_view_(root_view) {}
+  explicit RootWindowDelegateImpl(ConnectionManager* connection_manager)
+      : connection_manager_(connection_manager) {}
   virtual ~RootWindowDelegateImpl() {}
 
   // aura::WindowDelegate:
   virtual gfx::Size GetMinimumSize() const OVERRIDE {
     return gfx::Size();
   }
   virtual gfx::Size GetMaximumSize() const OVERRIDE {
     return gfx::Size();
   }
   virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
                                const gfx::Rect& new_bounds) OVERRIDE {
+    connection_manager_->ProcessViewBoundsChanged(connection_manager_->root(),
+                                                  old_bounds,
+                                                  new_bounds);
   }
   virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
     return gfx::kNullCursor;
   }
   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
     return HTCAPTION;
   }
   virtual bool ShouldDescendIntoChildForEventHandling(
       aura::Window* child,
       const gfx::Point& location) OVERRIDE {
     return true;
   }
   virtual bool CanFocus() OVERRIDE {
     return true;
   }
   virtual void OnCaptureLost() OVERRIDE {
   }
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
-    PaintViewTree(canvas, root_view_, gfx::Point());
+    PaintViewTree(canvas, connection_manager_->root(), gfx::Point());
   }
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
   }
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
   }
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
   }
   virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {
   }
   virtual bool HasHitTestMask() const OVERRIDE {
     return false;
   }
   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {
   }
 
  private:
-  const ServerView* root_view_;
+  ConnectionManager* connection_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowDelegateImpl);
 };
 
 // TODO(sky): Remove once aura is removed from the service.
 class FocusClientImpl : public aura::client::FocusClient {
  public:
   FocusClientImpl() {}
   virtual ~FocusClientImpl() {}
 
@@ skipping 77 matching lines @@
                                    const gfx::Rect& bounds) {
   if (root_window_)
     root_window_->SchedulePaintInRect(ConvertRectToRoot(view, bounds));
 }
 
 void DisplayManager::OnCompositorCreated() {
   base::AutoReset<bool> resetter(&in_setup_, true);
   window_tree_host_->InitHost();
 
   window_delegate_.reset(
-      new RootWindowDelegateImpl(connection_manager_->root()));
+      new RootWindowDelegateImpl(connection_manager_));
   root_window_ = new aura::Window(window_delegate_.get());
   root_window_->Init(aura::WINDOW_LAYER_TEXTURED);
   root_window_->Show();
   root_window_->SetBounds(
       gfx::Rect(window_tree_host_->window()->bounds().size()));
   window_tree_host_->window()->AddChild(root_window_);
 
   connection_manager_->root()->SetBounds(
       gfx::Rect(window_tree_host_->window()->bounds().size()));
 
   window_tree_client_.reset(
       new WindowTreeClientImpl(window_tree_host_->window()));
 
   focus_client_.reset(new FocusClientImpl);
   aura::client::SetFocusClient(window_tree_host_->window(),
                                focus_client_.get());
 
   window_tree_host_->Show();
 
   delegate_->OnDisplayManagerWindowTreeHostCreated();
 }
 
 }  // namespace service
 }  // namespace mojo