Rename ViewManagerService,ViewManagerClient -> ViewTree,ViewTreeClient

components/view_manager/public/cpp/lib/view.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/public/cpp/view.h"
 
 #include <set>
 #include <string>
 
-#include "components/view_manager/public/cpp/lib/view_manager_client_impl.h"
 #include "components/view_manager/public/cpp/lib/view_private.h"
+#include "components/view_manager/public/cpp/lib/view_tree_client_impl.h"
 #include "components/view_manager/public/cpp/view_observer.h"
 #include "components/view_manager/public/cpp/view_tracker.h"
 #include "mojo/application/public/cpp/service_provider_impl.h"
 
 namespace mojo {
 
 namespace {
 
 void NotifyViewTreeChangeAtReceiver(
     View* receiver,
@@ skipping 145 matching lines @@
   View* view_;
   const Rect old_bounds_;
   const Rect new_bounds_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedSetBoundsNotifier);
 };
 
 // Some operations are only permitted in the connection that created the view.
 bool OwnsView(ViewManager* manager, View* view) {
   return !manager ||
-      static_cast<ViewManagerClientImpl*>(manager)->OwnsView(view->id());
+      static_cast<ViewTreeClientImpl*>(manager)->OwnsView(view->id());
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // View, public:
 
 void View::Destroy() {
   if (!OwnsView(manager_, this))
     return;
 
   if (manager_)
-    static_cast<ViewManagerClientImpl*>(manager_)->DestroyView(id_);
+    static_cast<ViewTreeClientImpl*>(manager_)->DestroyView(id_);
   while (!children_.empty()) {
     View* child = children_.front();
     if (!OwnsView(manager_, child)) {
       ViewPrivate(child).ClearParent();
       children_.erase(children_.begin());
     } else {
       child->Destroy();
       DCHECK(std::find(children_.begin(), children_.end(), child) ==
              children_.end());
     }
   }
   LocalDestroy();
 }
 
 void View::SetBounds(const Rect& bounds) {
   if (!OwnsView(manager_, this))
     return;
 
   if (bounds_.Equals(bounds))
     return;
 
   if (manager_)
-    static_cast<ViewManagerClientImpl*>(manager_)->SetBounds(id_, bounds);
+    static_cast<ViewTreeClientImpl*>(manager_)->SetBounds(id_, bounds);
   LocalSetBounds(bounds_, bounds);
 }
 
 void View::SetVisible(bool value) {
   if (visible_ == value)
     return;
 
   if (manager_)
-    static_cast<ViewManagerClientImpl*>(manager_)->SetVisible(id_, value);
+    static_cast<ViewTreeClientImpl*>(manager_)->SetVisible(id_, value);
   LocalSetVisible(value);
 }
 
 void View::SetSharedProperty(const std::string& name,
                              const std::vector<uint8_t>* value) {
   std::vector<uint8_t> old_value;
   std::vector<uint8_t>* old_value_ptr = nullptr;
   auto it = properties_.find(name);
   if (it != properties_.end()) {
     old_value = it->second;
@@ skipping 14 matching lines @@
   }
 
   // TODO: add test coverage of this (450303).
   if (manager_) {
     Array<uint8_t> transport_value;
     if (value) {
       transport_value.resize(value->size());
       if (value->size())
         memcpy(&transport_value.front(), &(value->front()), value->size());
     }
-    static_cast<ViewManagerClientImpl*>(manager_)->SetProperty(
+    static_cast<ViewTreeClientImpl*>(manager_)->SetProperty(
         id_, name, transport_value.Pass());
   }
 
   FOR_EACH_OBSERVER(
       ViewObserver, observers_,
       OnViewSharedPropertyChanged(this, name, old_value_ptr, value));
 }
 
 bool View::IsDrawn() const {
   if (!visible_)
@@ skipping 16 matching lines @@
   return root;
 }
 
 void View::AddChild(View* child) {
   // TODO(beng): not necessarily valid to all connections, but possibly to the
   //             embeddee in an embedder-embeddee relationship.
   if (manager_)
     CHECK_EQ(child->view_manager(), manager_);
   LocalAddChild(child);
   if (manager_)
-    static_cast<ViewManagerClientImpl*>(manager_)->AddChild(child->id(), id_);
+    static_cast<ViewTreeClientImpl*>(manager_)->AddChild(child->id(), id_);
 }
 
 void View::RemoveChild(View* child) {
   // TODO(beng): not necessarily valid to all connections, but possibly to the
   //             embeddee in an embedder-embeddee relationship.
   if (manager_)
     CHECK_EQ(child->view_manager(), manager_);
   LocalRemoveChild(child);
   if (manager_) {
-    static_cast<ViewManagerClientImpl*>(manager_)->RemoveChild(child->id(),
-                                                               id_);
+    static_cast<ViewTreeClientImpl*>(manager_)->RemoveChild(child->id(), id_);
   }
 }
 
 void View::MoveToFront() {
   if (!parent_ || parent_->children_.back() == this)
     return;
   Reorder(parent_->children_.back(), ORDER_DIRECTION_ABOVE);
 }
 
 void View::MoveToBack() {
   if (!parent_ || parent_->children_.front() == this)
     return;
   Reorder(parent_->children_.front(), ORDER_DIRECTION_BELOW);
 }
 
 void View::Reorder(View* relative, OrderDirection direction) {
   if (!LocalReorder(relative, direction))
     return;
   if (manager_) {
-    static_cast<ViewManagerClientImpl*>(manager_)->Reorder(id_,
-                                                            relative->id(),
-                                                            direction);
+    static_cast<ViewTreeClientImpl*>(manager_)->Reorder(id_, relative->id(),
+                                                        direction);
   }
 }
 
 bool View::Contains(View* child) const {
   if (!child)
     return false;
   if (child == this)
     return true;
   if (manager_)
     CHECK_EQ(child->view_manager(), manager_);
@@ skipping 12 matching lines @@
   for (; it != children_.end(); ++it) {
     View* view = (*it)->GetChildById(id);
     if (view)
       return view;
   }
   return NULL;
 }
 
 void View::SetSurfaceId(SurfaceIdPtr id) {
   if (manager_) {
-    static_cast<ViewManagerClientImpl*>(manager_)->SetSurfaceId(id_, id.Pass());
+    static_cast<ViewTreeClientImpl*>(manager_)->SetSurfaceId(id_, id.Pass());
   }
 }
 
 void View::SetTextInputState(TextInputStatePtr state) {
   if (manager_) {
-    static_cast<ViewManagerClientImpl*>(manager_)
+    static_cast<ViewTreeClientImpl*>(manager_)
         ->SetViewTextInputState(id_, state.Pass());
   }
 }
 
 void View::SetImeVisibility(bool visible, TextInputStatePtr state) {
   // SetImeVisibility() shouldn't be used if the view is not editable.
   DCHECK(state.is_null() || state->type != TEXT_INPUT_TYPE_NONE);
   if (manager_) {
-    static_cast<ViewManagerClientImpl*>(manager_)
+    static_cast<ViewTreeClientImpl*>(manager_)
         ->SetImeVisibility(id_, visible, state.Pass());
   }
 }
 
 void View::SetFocus() {
   if (manager_)
-    static_cast<ViewManagerClientImpl*>(manager_)->SetFocus(id_);
+    static_cast<ViewTreeClientImpl*>(manager_)->SetFocus(id_);
 }
 
 bool View::HasFocus() const {
   return manager_ && manager_->GetFocusedView() == this;
 }
 
-void View::Embed(ViewManagerClientPtr client) {
+void View::Embed(ViewTreeClientPtr client) {
   if (PrepareForEmbed())
-    static_cast<ViewManagerClientImpl*>(manager_)->Embed(id_, client.Pass());
+    static_cast<ViewTreeClientImpl*>(manager_)->Embed(id_, client.Pass());
 }
 
 void View::EmbedAllowingReembed(mojo::URLRequestPtr request) {
   if (PrepareForEmbed()) {
-    static_cast<ViewManagerClientImpl*>(manager_)
+    static_cast<ViewTreeClientImpl*>(manager_)
         ->EmbedAllowingReembed(request.Pass(), id_);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // View, protected:
 
 namespace {
 
 ViewportMetricsPtr CreateEmptyViewportMetrics() {
@@ skipping 22 matching lines @@
 
   // We may still have children. This can happen if the embedder destroys the
   // root while we're still alive.
   while (!children_.empty()) {
     View* child = children_.front();
     LocalRemoveChild(child);
     DCHECK(children_.empty() || children_.front() != child);
   }
 
   // TODO(beng): It'd be better to do this via a destruction observer in the
-  //             ViewManagerClientImpl.
+  //             ViewTreeClientImpl.
   if (manager_)
-    static_cast<ViewManagerClientImpl*>(manager_)->RemoveView(id_);
+    static_cast<ViewTreeClientImpl*>(manager_)->RemoveView(id_);
 
   // Clear properties.
   for (auto& pair : prop_map_) {
     if (pair.second.deallocator)
       (*pair.second.deallocator)(pair.second.value);
   }
   prop_map_.clear();
 
   FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewDestroyed(this));
 
   if (manager_ && manager_->GetRoot() == this)
-    static_cast<ViewManagerClientImpl*>(manager_)->OnRootDestroyed(this);
+    static_cast<ViewTreeClientImpl*>(manager_)->OnRootDestroyed(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // View, private:
 
 View::View(ViewManager* manager, Id id)
     : manager_(manager),
       id_(id),
       parent_(nullptr),
       viewport_metrics_(CreateEmptyViewportMetrics()),
@@ skipping 137 matching lines @@
   // Start with the parent as we already notified |this|
   // in NotifyViewVisibilityChangedDown.
   for (View* view = parent(); view; view = view->parent()) {
     bool ret = view->NotifyViewVisibilityChangedAtReceiver(target);
     DCHECK(ret);
   }
 }
 
 bool View::PrepareForEmbed() {
   if (!OwnsView(manager_, this) &&
-      !static_cast<ViewManagerClientImpl*>(manager_)->is_embed_root()) {
+      !static_cast<ViewTreeClientImpl*>(manager_)->is_embed_root()) {
     return false;
   }
 
   while (!children_.empty())
     RemoveChild(children_[0]);
   return true;
 }
 
 }  // namespace mojo