Remove dependency on ui from view_manager.

mojo/examples/window_manager/window_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 "base/bind.h"
 #include "base/macros.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/examples/keyboard/keyboard.mojom.h"
@@ skipping 137 matching lines @@
   virtual ~KeyboardManager() {
     if (view_)
       view_->parent()->RemoveObserver(this);
   }
 
   View* view() { return view_; }
 
   void Init(ApplicationImpl* application,
             ViewManager* view_manager,
             View* parent,
-            const gfx::Rect& bounds) {
+            const Rect& bounds) {
     view_manager_ = view_manager;
     view_ = View::Create(view_manager);
     view_->SetBounds(bounds);
     parent->AddChild(view_);
     view_->Embed("mojo:keyboard");
     application->ConnectToService("mojo:keyboard", &keyboard_service_);
     keyboard_service_.set_client(this);
     parent->AddObserver(this);
   }
 
-  void Show(Id view_id, const gfx::Rect& bounds) {
+  void Show(Id view_id, const Rect& bounds) {
     keyboard_service_->SetTarget(view_id);
     view_->SetVisible(true);
   }
 
   void Hide(Id view_id) {
     keyboard_service_->SetTarget(0);
     view_->SetVisible(false);
   }
 
  private:
   // KeyboardClient:
   virtual void OnKeyboardEvent(Id view_id,
                                int32_t code,
                                int32_t flags) override {
     // TODO(sky): figure this out. Code use to dispatch events, but that's a
     // hack. Instead strings should be passed through, or maybe a richer text
     // input interface.
   }
 
   // Overridden from ViewObserver:
   virtual void OnViewBoundsChanged(View* parent,
-                                   const gfx::Rect& old_bounds,
-                                   const gfx::Rect& new_bounds) override {
-    gfx::Rect keyboard_bounds(view_->bounds());
-    keyboard_bounds.set_y(new_bounds.bottom() - keyboard_bounds.height());
-    keyboard_bounds.set_width(keyboard_bounds.width() +
-                              new_bounds.width() - old_bounds.width());
+                                   const Rect& old_bounds,
+                                   const Rect& new_bounds) override {
+    Rect keyboard_bounds(view_->bounds());
+    keyboard_bounds.y =
+        new_bounds.y + new_bounds.height - keyboard_bounds.height;
+    keyboard_bounds.width =
+        keyboard_bounds.width + new_bounds.width - old_bounds.width;
     view_->SetBounds(keyboard_bounds);
   }
   virtual void OnViewDestroyed(View* parent) override {
     DCHECK_EQ(parent, view_->parent());
     parent->RemoveObserver(this);
     view_ = NULL;
   }
 
   KeyboardServicePtr keyboard_service_;
   ViewManager* view_manager_;
@@ skipping 17 matching lines @@
         launcher_ui_view_id_(launcher_ui_view_id),
         control_panel_view_id_(control_panel_view_id) {}
   virtual ~RootLayoutManager() {
     if (root_)
       root_->RemoveObserver(this);
   }
 
  private:
   // Overridden from ViewObserver:
   virtual void OnViewBoundsChanged(View* view,
-                                   const gfx::Rect& old_bounds,
-                                   const gfx::Rect& new_bounds) override {
+                                   const Rect& old_bounds,
+                                   const Rect& new_bounds) override {
     DCHECK_EQ(view, root_);
 
     View* content_view = view_manager_->GetViewById(content_view_id_);
     content_view->SetBounds(new_bounds);
 
-    int delta_width = new_bounds.width() - old_bounds.width();
-    int delta_height = new_bounds.height() - old_bounds.height();
+    int delta_width = new_bounds.width - old_bounds.width;
+    int delta_height = new_bounds.height - old_bounds.height;
 
     View* launcher_ui_view =
         view_manager_->GetViewById(launcher_ui_view_id_);
-    gfx::Rect launcher_ui_bounds(launcher_ui_view->bounds());
-    launcher_ui_bounds.set_width(launcher_ui_bounds.width() + delta_width);
+    Rect launcher_ui_bounds(launcher_ui_view->bounds());
+    launcher_ui_bounds.width += delta_width;
     launcher_ui_view->SetBounds(launcher_ui_bounds);
 
     View* control_panel_view =
         view_manager_->GetViewById(control_panel_view_id_);
-    gfx::Rect control_panel_bounds(control_panel_view->bounds());
-    control_panel_bounds.set_x(control_panel_bounds.x() + delta_width);
+    Rect control_panel_bounds(control_panel_view->bounds());
+    control_panel_bounds.x += delta_width;
     control_panel_view->SetBounds(control_panel_bounds);
 
     const View::Children& content_views = content_view->children();
     View::Children::const_iterator iter = content_views.begin();
     for(; iter != content_views.end(); ++iter) {
       View* view = *iter;
       if (view->id() == control_panel_view->id() ||
           view->id() == launcher_ui_view->id())
         continue;
-      gfx::Rect view_bounds(view->bounds());
-      view_bounds.set_width(view_bounds.width() + delta_width);
-      view_bounds.set_height(view_bounds.height() + delta_height);
+      Rect view_bounds(view->bounds());
+      view_bounds.width += delta_width;
+      view_bounds.height += delta_height;
       view->SetBounds(view_bounds);
     }
   }
   virtual void OnViewDestroyed(View* view) override {
     DCHECK_EQ(view, root_);
     root_->RemoveObserver(this);
     root_ = NULL;
   }
 
   View* root_;
@@ skipping 56 matching lines @@
   }
 
   void CloseWindow(Id view_id) {
     WindowVector::iterator iter = GetWindowByViewId(view_id);
     DCHECK(iter != windows_.end());
     Window* window = *iter;
     windows_.erase(iter);
     window->view()->Destroy();
   }
 
-  void ShowKeyboard(Id view_id, const gfx::Rect& bounds) {
+  void ShowKeyboard(Id view_id, const Rect& bounds) {
     // TODO: this needs to validate |view_id|. That is, it shouldn't assume
     // |view_id| is valid and it also needs to make sure the client that sent
     // this really owns |view_id|.
     // TODO: honor |bounds|.
     if (!keyboard_manager_) {
       keyboard_manager_.reset(new KeyboardManager);
       View* parent = view_manager_->GetRoots().back();
       int ideal_height = 200;
       // TODO(sky): 10 is a bit of a hack here. There is a bug that causes
       // white strips to appear when 0 is used. Figure this out!
-      const gfx::Rect keyboard_bounds(
-          10, parent->bounds().height() - ideal_height,
-          parent->bounds().width() - 20, ideal_height);
+      Rect keyboard_bounds;
+      keyboard_bounds.x =  10;
+      keyboard_bounds.y = parent->bounds().height - ideal_height;
+      keyboard_bounds.width = parent->bounds().width - 20;
+      keyboard_bounds.height = ideal_height;
       keyboard_manager_->Init(app_, view_manager_, parent, keyboard_bounds);
     }
     keyboard_manager_->Show(view_id, bounds);
   }
 
   void HideKeyboard(Id view_id) {
     // See comment in ShowKeyboard() about validating args.
     if (keyboard_manager_)
       keyboard_manager_->Hide(view_id);
   }
@@ skipping 36 matching lines @@
   // Overridden from ViewManagerDelegate:
   virtual void OnEmbed(ViewManager* view_manager,
                        View* root,
                        ServiceProviderImpl* exported_services,
                        scoped_ptr<ServiceProvider> imported_services) override {
     DCHECK(!view_manager_);
     view_manager_ = view_manager;
 
     View* view = View::Create(view_manager_);
     root->AddChild(view);
-    view->SetBounds(gfx::Rect(root->bounds().size()));
+    Rect rect;
+    rect.width = root->bounds().width;
+    rect.height = root->bounds().height;
+    view->SetBounds(rect);
     content_view_id_ = view->id();
 
     Id launcher_ui_id = CreateLauncherUI();
     Id control_panel_id = CreateControlPanel(view);
 
     root_layout_manager_.reset(
         new RootLayoutManager(view_manager, root,
                               content_view_id_,
                               launcher_ui_id,
                               control_panel_id));
@@ skipping 56 matching lines @@
       dest_view = CreateWindow();
       windows_.push_back(dest_view);
     }
 
     dest_view->Embed(url);
   }
 
   // TODO(beng): proper layout manager!!
   Id CreateLauncherUI() {
     View* view = view_manager_->GetViewById(content_view_id_);
-    gfx::Rect bounds = view->bounds();
-    bounds.Inset(kBorderInset, kBorderInset);
-    bounds.set_height(kTextfieldHeight);
+    Rect bounds = view->bounds();
+    bounds.x += kBorderInset;
+    bounds.y += kBorderInset;
+    bounds.width -= 2 * kBorderInset;
+    bounds.height = kTextfieldHeight;
     launcher_ui_ = CreateWindow(bounds);
     launcher_ui_->Embed("mojo:browser");
     return launcher_ui_->view()->id();
   }
 
   Window* CreateWindow() {
     View* view = view_manager_->GetViewById(content_view_id_);
-    gfx::Rect bounds(kBorderInset,
-                     2 * kBorderInset + kTextfieldHeight,
-                     view->bounds().width() - 3 * kBorderInset -
-                         kControlPanelWidth,
-                     view->bounds().height() -
-                         (3 * kBorderInset + kTextfieldHeight));
+    Rect bounds;
+    bounds.x = kBorderInset;
+    bounds.y = 2 * kBorderInset + kTextfieldHeight;
+    bounds.width = view->bounds().width - 3 * kBorderInset - kControlPanelWidth;
+    bounds.height =
+        view->bounds().height - (3 * kBorderInset + kTextfieldHeight);
     if (!windows_.empty()) {
-      gfx::Point position = windows_.back()->view()->bounds().origin();
-      position.Offset(35, 35);
-      bounds.set_origin(position);
+      bounds.x = windows_.back()->view()->bounds().x + 35;
+      bounds.y = windows_.back()->view()->bounds().y + 35;
     }
     return CreateWindow(bounds);
   }
 
-  Window* CreateWindow(const gfx::Rect& bounds) {
+  Window* CreateWindow(const Rect& bounds) {
     View* content = view_manager_->GetViewById(content_view_id_);
     View* view = View::Create(view_manager_);
     content->AddChild(view);
     view->SetBounds(bounds);
     view->SetFocus();
     return new Window(this, view);
   }
 
   bool IsDescendantOfKeyboard(View* target) {
     return keyboard_manager_.get() &&
         keyboard_manager_->view()->Contains(target);
   }
 
   Id CreateControlPanel(View* root) {
     View* view = View::Create(view_manager_);
     root->AddChild(view);
 
-    gfx::Rect bounds(root->bounds().width() - kControlPanelWidth -
-                         kBorderInset,
-                     kBorderInset * 2 + kTextfieldHeight,
-                     kControlPanelWidth,
-                     root->bounds().height() - kBorderInset * 3 -
-                         kTextfieldHeight);
+    Rect bounds;
+    bounds.x = root->bounds().width - kControlPanelWidth - kBorderInset;
+    bounds.y = kBorderInset * 2 + kTextfieldHeight;
+    bounds.width = kControlPanelWidth;
+    bounds.height =
+        root->bounds().height - kBorderInset * 3 - kTextfieldHeight;
     view->SetBounds(bounds);
 
     debug_panel_ = new DebugPanel(this, shell_, view);
     return view->id();
   }
 
   WindowVector::iterator GetWindowByViewId(Id view_id) {
     for (std::vector<Window*>::iterator iter = windows_.begin();
          iter != windows_.end();
          ++iter) {
@@ skipping 25 matching lines @@
   ApplicationImpl* app_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManager);
 };
 
 void WindowManagerConnection::CloseWindow(Id view_id) {
   window_manager_->CloseWindow(view_id);
 }
 
 void WindowManagerConnection::ShowKeyboard(Id view_id, RectPtr bounds) {
-  window_manager_->ShowKeyboard(view_id, bounds.To<gfx::Rect>());
+  window_manager_->ShowKeyboard(view_id, *bounds);
 }
 
 void WindowManagerConnection::HideKeyboard(Id view_id) {
   window_manager_->HideKeyboard(view_id);
 }
 
 void NavigatorHostImpl::DidNavigateLocally(const mojo::String& url) {
   window_manager_->DidNavigateLocally(view_id_, url);
 }
 
 void NavigatorHostImpl::RequestNavigate(Target target, URLRequestPtr request) {
   window_manager_->RequestNavigate(view_id_, target, request.Pass());
 }
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::WindowManager);
   return runner.Run(shell_handle);
 }