components/mus/public/interfaces View => Window

components/mus/public/cpp/lib/window.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/mus/public/cpp/window.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 70 matching lines @@
   if (it != children->end()) {
     children->erase(it);
     WindowPrivate(child).ClearParent();
   }
 }
 
 class ScopedOrderChangedNotifier {
  public:
   ScopedOrderChangedNotifier(Window* window,
                              Window* relative_window,
-                             mojo::OrderDirection direction)
+                             mojom::OrderDirection direction)
       : window_(window),
         relative_window_(relative_window),
         direction_(direction) {
     FOR_EACH_OBSERVER(
         WindowObserver, *WindowPrivate(window_).observers(),
         OnWindowReordering(window_, relative_window_, direction_));
   }
   ~ScopedOrderChangedNotifier() {
     FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window_).observers(),
                       OnWindowReordered(window_, relative_window_, direction_));
   }
 
  private:
   Window* window_;
   Window* relative_window_;
-  mojo::OrderDirection direction_;
+  mojom::OrderDirection direction_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedOrderChangedNotifier);
 };
 
 // Returns true if the order actually changed.
 bool ReorderImpl(Window::Children* children,
                  Window* window,
                  Window* relative,
-                 mojo::OrderDirection direction) {
+                 mojom::OrderDirection direction) {
   DCHECK(relative);
   DCHECK_NE(window, relative);
   DCHECK_EQ(window->parent(), relative->parent());
 
   const size_t child_i =
       std::find(children->begin(), children->end(), window) - children->begin();
   const size_t target_i =
       std::find(children->begin(), children->end(), relative) -
       children->begin();
-  if ((direction == mojo::ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
-      (direction == mojo::ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
+  if ((direction == mojom::ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
+      (direction == mojom::ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
     return false;
   }
 
   ScopedOrderChangedNotifier notifier(window, relative, direction);
 
-  const size_t dest_i = direction == mojo::ORDER_DIRECTION_ABOVE
+  const size_t dest_i = direction == mojom::ORDER_DIRECTION_ABOVE
                             ? (child_i < target_i ? target_i : target_i + 1)
                             : (child_i < target_i ? target_i - 1 : target_i);
   children->erase(children->begin() + child_i);
   children->insert(children->begin() + dest_i, window);
 
   return true;
 }
 
 class ScopedSetBoundsNotifier {
  public:
@@ skipping 82 matching lines @@
 void Window::SetVisible(bool value) {
   if (visible_ == value)
     return;
 
   if (connection_)
     static_cast<WindowTreeClientImpl*>(connection_)->SetVisible(id_, value);
   LocalSetVisible(value);
 }
 
 scoped_ptr<WindowSurface> Window::RequestSurface() {
-  mojo::SurfacePtr surface;
-  mojo::SurfaceClientPtr client;
-  mojo::InterfaceRequest<mojo::SurfaceClient> client_request =
+  mojom::SurfacePtr surface;
+  mojom::SurfaceClientPtr client;
+  mojo::InterfaceRequest<mojom::SurfaceClient> client_request =
       GetProxy(&client);
   static_cast<WindowTreeClientImpl*>(connection_)
       ->RequestSurface(id_, GetProxy(&surface), client.Pass());
   return make_scoped_ptr(
       new WindowSurface(surface.PassInterface(), client_request.Pass()));
 }
 
 void Window::SetSharedProperty(const std::string& name,
                                const std::vector<uint8_t>* value) {
   std::vector<uint8_t> old_value;
@@ skipping 73 matching lines @@
   LocalRemoveChild(child);
   if (connection_) {
     static_cast<WindowTreeClientImpl*>(connection_)
         ->RemoveChild(child->id(), id_);
   }
 }
 
 void Window::MoveToFront() {
   if (!parent_ || parent_->children_.back() == this)
     return;
-  Reorder(parent_->children_.back(), mojo::ORDER_DIRECTION_ABOVE);
+  Reorder(parent_->children_.back(), mojom::ORDER_DIRECTION_ABOVE);
 }
 
 void Window::MoveToBack() {
   if (!parent_ || parent_->children_.front() == this)
     return;
-  Reorder(parent_->children_.front(), mojo::ORDER_DIRECTION_BELOW);
+  Reorder(parent_->children_.front(), mojom::ORDER_DIRECTION_BELOW);
 }
 
-void Window::Reorder(Window* relative, mojo::OrderDirection direction) {
+void Window::Reorder(Window* relative, mojom::OrderDirection direction) {
   if (!LocalReorder(relative, direction))
     return;
   if (connection_) {
     static_cast<WindowTreeClientImpl*>(connection_)
         ->Reorder(id_, relative->id(), direction);
   }
 }
 
 bool Window::Contains(Window* child) const {
   if (!child)
@@ skipping 19 matching lines @@
     Window* window = (*it)->GetChildById(id);
     if (window)
       return window;
   }
   return NULL;
 }
 
 void Window::SetTextInputState(mojo::TextInputStatePtr state) {
   if (connection_) {
     static_cast<WindowTreeClientImpl*>(connection_)
-        ->SetViewTextInputState(id_, state.Pass());
+        ->SetWindowTextInputState(id_, state.Pass());
   }
 }
 
 void Window::SetImeVisibility(bool visible, mojo::TextInputStatePtr state) {
   // SetImeVisibility() shouldn't be used if the window is not editable.
   DCHECK(state.is_null() || state->type != mojo::TEXT_INPUT_TYPE_NONE);
   if (connection_) {
     static_cast<WindowTreeClientImpl*>(connection_)
         ->SetImeVisibility(id_, visible, state.Pass());
   }
 }
 
 void Window::SetFocus() {
   if (connection_)
     static_cast<WindowTreeClientImpl*>(connection_)->SetFocus(id_);
 }
 
 bool Window::HasFocus() const {
   return connection_ && connection_->GetFocusedWindow() == this;
 }
 
-void Window::Embed(mojo::ViewTreeClientPtr client) {
-  Embed(client.Pass(), mojo::ViewTree::ACCESS_POLICY_DEFAULT,
+void Window::Embed(mus::mojom::WindowTreeClientPtr client) {
+  Embed(client.Pass(), mus::mojom::WindowTree::ACCESS_POLICY_DEFAULT,
         base::Bind(&EmptyEmbedCallback));
 }
 
-void Window::Embed(mojo::ViewTreeClientPtr client,
+void Window::Embed(mus::mojom::WindowTreeClientPtr client,
                    uint32_t policy_bitmask,
                    const EmbedCallback& callback) {
   if (PrepareForEmbed()) {
     static_cast<WindowTreeClientImpl*>(connection_)
         ->Embed(id_, client.Pass(), policy_bitmask, callback);
   } else {
     callback.Run(false, 0);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Window, protected:
 
 namespace {
 
-mojo::ViewportMetricsPtr CreateEmptyViewportMetrics() {
-  mojo::ViewportMetricsPtr metrics = mojo::ViewportMetrics::New();
+mojom::ViewportMetricsPtr CreateEmptyViewportMetrics() {
+  mojom::ViewportMetricsPtr metrics = mojom::ViewportMetrics::New();
   metrics->size_in_pixels = mojo::Size::New();
   // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
   // once that's fixed.
   return metrics.Pass();
 }
 
 }  // namespace
 
 Window::Window()
     : connection_(NULL),
@@ skipping 84 matching lines @@
   children_.push_back(child);
   child->parent_ = this;
 }
 
 void Window::LocalRemoveChild(Window* child) {
   DCHECK_EQ(this, child->parent());
   ScopedTreeNotifier notifier(child, this, NULL);
   RemoveChildImpl(child, &children_);
 }
 
-bool Window::LocalReorder(Window* relative, mojo::OrderDirection direction) {
+bool Window::LocalReorder(Window* relative, mojom::OrderDirection direction) {
   return ReorderImpl(&parent_->children_, this, relative, direction);
 }
 
 void Window::LocalSetBounds(const mojo::Rect& old_bounds,
                             const mojo::Rect& new_bounds) {
   DCHECK(old_bounds.x == bounds_.x);
   DCHECK(old_bounds.y == bounds_.y);
   DCHECK(old_bounds.width == bounds_.width);
   DCHECK(old_bounds.height == bounds_.height);
   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
   if (bounds_.width != new_bounds.width ||
       bounds_.height != new_bounds.height) {
     client_area_.x = 0;
     client_area_.y = 0;
     client_area_.width = new_bounds.width;
     client_area_.height = new_bounds.height;
   }
   bounds_ = new_bounds;
 }
 
 void Window::LocalSetClientArea(const mojo::Rect& new_client_area) {
   const mojo::Rect old_client_area = client_area_;
   client_area_ = new_client_area;
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowClientAreaChanged(this, old_client_area));
 }
 
-void Window::LocalSetViewportMetrics(const mojo::ViewportMetrics& old_metrics,
-                                     const mojo::ViewportMetrics& new_metrics) {
+void Window::LocalSetViewportMetrics(
+    const mojom::ViewportMetrics& old_metrics,
+    const mojom::ViewportMetrics& new_metrics) {
   // TODO(eseidel): We could check old_metrics against viewport_metrics_.
   viewport_metrics_ = new_metrics.Clone();
   FOR_EACH_OBSERVER(
       WindowObserver, observers_,
       OnWindowViewportMetricsChanged(this, old_metrics, new_metrics));
 }
 
 void Window::LocalSetDrawn(bool value) {
   if (drawn_ == value)
     return;
@@ skipping 73 matching lines @@
       !static_cast<WindowTreeClientImpl*>(connection_)->is_embed_root()) {
     return false;
   }
 
   while (!children_.empty())
     RemoveChild(children_[0]);
   return true;
 }
 
 }  // namespace mus