Remove the keyboard from the browser demo.

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 "examples/keyboard/keyboard.mojom.h"
 #include "examples/window_manager/debug_panel_host.mojom.h"
 #include "examples/window_manager/window_manager.mojom.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/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/interface_factory_impl.h"
@@ skipping 32 matching lines @@
 
 class WindowManagerConnection : public InterfaceImpl<IWindowManager> {
  public:
   explicit WindowManagerConnection(WindowManager* window_manager)
       : window_manager_(window_manager) {}
   virtual ~WindowManagerConnection() {}
 
  private:
   // Overridden from IWindowManager:
   virtual void CloseWindow(Id view_id) override;
-  virtual void ShowKeyboard(Id view_id, RectPtr bounds) override;
-  virtual void HideKeyboard(Id view_id) override;
 
   WindowManager* window_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerConnection);
 };
 
 class NavigatorHostImpl : public InterfaceImpl<NavigatorHost> {
  public:
   explicit NavigatorHostImpl(WindowManager* window_manager, Id view_id)
       : window_manager_(window_manager), view_id_(view_id) {}
   virtual ~NavigatorHostImpl() {
   }
 
  private:
   virtual void DidNavigateLocally(const mojo::String& url) override;
   virtual void RequestNavigate(Target target, URLRequestPtr request) override;
 
   WindowManager* window_manager_;
   Id view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigatorHostImpl);
 };
 
-class KeyboardManager : public KeyboardClient,
-                        public ViewObserver {
- public:
-  KeyboardManager() : view_manager_(NULL), view_(NULL) {
-  }
-  virtual ~KeyboardManager() {
-    if (view_)
-      view_->parent()->RemoveObserver(this);
-  }
-
-  View* view() { return view_; }
-
-  void Init(ApplicationImpl* application,
-            ViewManager* view_manager,
-            View* parent,
-            const Rect& bounds) {
-    view_manager_ = view_manager;
-    view_ = view_manager->CreateView();
-    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 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 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_;
-
-  // View the keyboard is attached to.
-  View* view_;
-
-  DISALLOW_COPY_AND_ASSIGN(KeyboardManager);
-};
-
 class RootLayoutManager : public ViewObserver {
  public:
   RootLayoutManager(ViewManager* view_manager,
                     View* root,
                     Id content_view_id,
                     Id launcher_ui_view_id,
                     Id control_panel_view_id)
       : root_(root),
         view_manager_(view_manager),
         content_view_id_(content_view_id),
@@ skipping 112 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 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_->GetRoot();
-      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!
-      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);
-  }
 
   void DidNavigateLocally(uint32 source_view_id, const mojo::String& url) {
     LOG(ERROR) << "DidNavigateLocally: source_view_id: " << source_view_id
                << " url: " << url.To<std::string>();
   }
 
   void RequestNavigate(uint32 source_view_id,
                        Target target,
                        URLRequestPtr request) {
     OnLaunch(source_view_id, target, request->url);
@@ skipping 82 matching lines @@
       const String& url,
       InterfaceRequest<ServiceProvider> service_provider) override {
     const Id kInvalidSourceViewId = 0;
     OnLaunch(kInvalidSourceViewId, TARGET_DEFAULT, url);
   }
 
   // Overridden from ui::EventHandler:
   virtual void OnEvent(ui::Event* event) override {
     View* view =
         static_cast<window_manager::ViewTarget*>(event->target())->view();
-    if (event->type() == ui::ET_MOUSE_PRESSED &&
-        !IsDescendantOfKeyboard(view)) {
+    if (event->type() == ui::ET_MOUSE_PRESSED)
       view->SetFocus();
-    }
   }
 
   void OnLaunch(uint32 source_view_id,
                 Target requested_target,
                 const mojo::String& url) {
     Target target = navigation_target_;
     if (target == TARGET_DEFAULT) {
       if (requested_target != TARGET_DEFAULT) {
         target = requested_target;
       } else {
@@ skipping 52 matching lines @@
   Window* CreateWindow(const Rect& bounds) {
     View* content = view_manager_->GetViewById(content_view_id_);
     View* view = view_manager_->CreateView();
     content->AddChild(view);
     view->SetBounds(bounds);
     view->SetVisible(true);
     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_manager_->CreateView();
     root->AddChild(view);
 
     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;
@@ skipping 27 matching lines @@
       window_manager_factory_;
 
   scoped_ptr<mojo::ServiceProvider> debug_panel_;
   Window* launcher_ui_;
   WindowVector windows_;
   ViewManager* view_manager_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
 
   scoped_ptr<window_manager::WindowManagerApp> window_manager_app_;
 
-  // Id of the view most content is added to. The keyboard is NOT added here.
+  // Id of the view most content is added to.
   Id content_view_id_;
 
   // Id of the debug panel.
   Id control_panel_id_;
 
   GURL url_;
   Target navigation_target_;
 
-  scoped_ptr<KeyboardManager> keyboard_manager_;
   ApplicationImpl* app_;
 
   mojo::Binding<examples::DebugPanelHost> binding_;
 
   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);
-}
-
-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);
 }