Adds a ServerViewObserver interface

services/view_manager/connection_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 "services/view_manager/connection_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
@@ skipping 98 matching lines @@
   connection_manager_->FinishChange();
 }
 
 ConnectionManager::ConnectionManager(ConnectionManagerDelegate* delegate,
                                      scoped_ptr<DisplayManager> display_manager,
                                      mojo::WindowManagerInternal* wm_internal)
     : delegate_(delegate),
       window_manager_client_connection_(nullptr),
       next_connection_id_(1),
       display_manager_(display_manager.Pass()),
-      root_(new ServerView(this, RootViewId())),
+      root_(CreateServerView(RootViewId())),
       wm_internal_(wm_internal),
       current_change_(nullptr),
       in_destructor_(false),
       animation_runner_(base::TimeTicks::Now()) {
   root_->SetBounds(gfx::Rect(800, 600));
   root_->SetVisible(true);
   display_manager_->Init(this);
 }
 
 ConnectionManager::~ConnectionManager() {
   in_destructor_ = true;
 
   STLDeleteValues(&connection_map_);
   // All the connections should have been destroyed.
   DCHECK(connection_map_.empty());
   root_.reset();
 }
 
+ServerView* ConnectionManager::CreateServerView(const ViewId& id) {
+  ServerView* view = new ServerView(this, id);
+  view->AddObserver(this);
+  return view;
+}
+
 ConnectionSpecificId ConnectionManager::GetAndAdvanceNextConnectionId() {
   const ConnectionSpecificId id = next_connection_id_++;
   DCHECK_LT(id, next_connection_id_);
   return id;
 }
 
 void ConnectionManager::OnConnectionError(ClientConnection* connection) {
   if (connection == window_manager_client_connection_) {
     window_manager_client_connection_ = nullptr;
     delegate_->OnLostConnectionToWindowManager();
@@ skipping 185 matching lines @@
 void ConnectionManager::DoAnimation() {
   if (!DecrementAnimatingViewsOpacity(root()))
     animation_timer_.Stop();
 }
 
 void ConnectionManager::AddConnection(ClientConnection* connection) {
   DCHECK_EQ(0u, connection_map_.count(connection->service()->id()));
   connection_map_[connection->service()->id()] = connection;
 }
 
-void ConnectionManager::OnWillDestroyView(ServerView* view) {
+void ConnectionManager::PrepareToDestroyView(ServerView* view) {
   if (!in_destructor_ && root_->Contains(view) && view != root_.get() &&
       view->id() != ClonedViewId()) {
     // We're about to destroy a view. Any cloned views need to be reparented
     // else the animation would no longer be visible. By moving to a visible
     // view, view->parent(), we ensure the animation is still visible.
     ServerView* parent_above = view;
     ReparentClonedViews(view->parent(), &parent_above, view);
   }
 
   animation_runner_.CancelAnimationForView(view);
 }
 
-void ConnectionManager::OnViewDestroyed(const ServerView* view) {
-  if (!in_destructor_)
-    ProcessViewDeleted(view->id());
-}
-
-void ConnectionManager::OnWillChangeViewHierarchy(ServerView* view,
-                                                  ServerView* new_parent,
-                                                  ServerView* old_parent) {
+void ConnectionManager::PrepareToChangeViewHierarchy(ServerView* view,
+                                                     ServerView* new_parent,
+                                                     ServerView* old_parent) {
   if (view->id() == ClonedViewId() || in_destructor_)
     return;
 
   if (root_->Contains(view) && view != root_.get()) {
     // We're about to reparent a view. Any cloned views need to be reparented
     // else the animation may be effected in unusual ways. For example, the view
     // could move to a new location such that the animation is entirely clipped.
     // By moving to view->parent() we ensure the animation is still visible.
     ServerView* parent_above = view;
     ReparentClonedViews(view->parent(), &parent_above, view);
   }
 
+  animation_runner_.CancelAnimationForView(view);
+}
+
+void ConnectionManager::PrepareToChangeViewVisibility(ServerView* view) {
+  if (in_destructor_)
+    return;
+
+  if (view != root_.get() && view->id() != ClonedViewId() &&
+      root_->Contains(view) && view->IsDrawn(root_.get())) {
+    // We're about to hide |view|, this would implicitly make any cloned views
+    // hide to. Reparent so that animations are still visible.

[Ben Goodger (Google), 2015/04/13 23:09:00]

hide too

+    ServerView* parent_above = view;
+    ReparentClonedViews(view->parent(), &parent_above, view);
+  }
+
+  const bool is_parent_drawn =
+      view->parent() && view->parent()->IsDrawn(root_.get());
+  if (!is_parent_drawn || !view->visible())
+    animation_runner_.CancelAnimationForView(view);
+}
+
+void ConnectionManager::OnScheduleViewPaint(const ServerView* view) {
+  if (!in_destructor_)
+    display_manager_->SchedulePaint(view, gfx::Rect(view->bounds().size()));
+}
+
+void ConnectionManager::OnViewDestroyed(const ServerView* view) {
+  if (!in_destructor_)
+    ProcessViewDeleted(view->id());
+}
+
+void ConnectionManager::OnWillChangeViewHierarchy(
+    const ServerView* view,
+    const ServerView* new_parent,
+    const ServerView* old_parent) {
+  if (view->id() == ClonedViewId() || in_destructor_)
+    return;
+
   ProcessWillChangeViewHierarchy(view, new_parent, old_parent);
-
-  animation_runner_.CancelAnimationForView(view);
 }
 
 void ConnectionManager::OnViewHierarchyChanged(const ServerView* view,
                                                const ServerView* new_parent,
                                                const ServerView* old_parent) {
   if (in_destructor_)
     return;
 
   ProcessViewHierarchyChanged(view, new_parent, old_parent);
 
@@ skipping 16 matching lines @@
 
   ProcessViewBoundsChanged(view, old_bounds, new_bounds);
   if (!view->parent())
     return;
 
   // TODO(sky): optimize this.
   display_manager_->SchedulePaint(view->parent(), old_bounds);
   display_manager_->SchedulePaint(view->parent(), new_bounds);
 }
 
-void ConnectionManager::OnViewSurfaceIdChanged(const ServerView* view) {
-  if (!in_destructor_)
-    display_manager_->SchedulePaint(view, gfx::Rect(view->bounds().size()));
-}
-
 void ConnectionManager::OnViewReordered(const ServerView* view,
                                         const ServerView* relative,
                                         mojo::OrderDirection direction) {
   if (!in_destructor_)
     display_manager_->SchedulePaint(view, gfx::Rect(view->bounds().size()));
 }
 
-void ConnectionManager::OnWillChangeViewVisibility(ServerView* view) {
+void ConnectionManager::OnWillChangeViewVisibility(const ServerView* view) {
   if (in_destructor_)
     return;
 
-  // Need to repaint if the view was drawn (which means it'll in the process of
+  // Need to repaint if the view was drawn (which means it's in the process of
   // hiding) or the view is transitioning to drawn.
   if (view->IsDrawn(root_.get()) || (!view->visible() && view->parent() &&
                                      view->parent()->IsDrawn(root_.get()))) {
     display_manager_->SchedulePaint(view->parent(), view->bounds());
   }
 
-  if (view != root_.get() && view->id() != ClonedViewId() &&
-      root_->Contains(view) && view->IsDrawn(root_.get())) {
-    // We're about to hide |view|, this would implicitly make any cloned views
-    // hide to. Reparent so that animations are still visible.
-    ServerView* parent_above = view;
-    ReparentClonedViews(view->parent(), &parent_above, view);
-  }
-
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessWillChangeViewVisibility(
         view, IsChangeSource(pair.first));
   }
-
-  const bool is_parent_drawn =
-      view->parent() && view->parent()->IsDrawn(root_.get());
-  if (!is_parent_drawn || !view->visible())
-    animation_runner_.CancelAnimationForView(view);
 }
 
 void ConnectionManager::OnViewSharedPropertyChanged(
     const ServerView* view,
     const std::string& name,
     const std::vector<uint8_t>* new_data) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewPropertyChanged(
         view, name, new_data, IsChangeSource(pair.first));
   }
 }
 
-void ConnectionManager::OnScheduleViewPaint(const ServerView* view) {
-  if (!in_destructor_)
-    display_manager_->SchedulePaint(view, gfx::Rect(view->bounds().size()));
-}
-
 void ConnectionManager::DispatchInputEventToView(mojo::Id transport_view_id,
                                                  mojo::EventPtr event) {
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
 
   ViewManagerServiceImpl* connection = GetConnectionWithRoot(view_id);
   if (!connection)
     connection = GetConnection(view_id.connection_id);
   if (connection) {
     connection->client()->OnViewInputEvent(
         transport_view_id, event.Pass(), base::Bind(&base::DoNothing));
   }
 }
 
 void ConnectionManager::SetViewportSize(mojo::SizePtr size) {
   gfx::Size new_size = size.To<gfx::Size>();
   display_manager_->SetViewportSize(new_size);
 }
 
 void ConnectionManager::CloneAndAnimate(mojo::Id transport_view_id) {
   CloneAndAnimate(ViewIdFromTransportId(transport_view_id));
 }
 
 }  // namespace view_manager