Refactors keyboard related code so mash can use a keyboard

ash/shell.cc

 // Copyright (c) 2012 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 "ash/shell.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "ash/display/screen_position_controller.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/first_run/first_run_helper_impl.h"
 #include "ash/focus_cycler.h"
 #include "ash/frame/custom_frame_view_ash.h"
 #include "ash/gpu_support.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/host/ash_window_tree_host_init_params.h"
 #include "ash/ime/input_method_event_handler.h"
+#include "ash/keyboard/keyboard_ui.h"
 #include "ash/keyboard_uma_event_filter.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/media_delegate.h"
+#include "ash/mojo_shell.h"
 #include "ash/new_window_delegate.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shelf/app_list_shelf_item_delegate.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_item_delegate.h"
 #include "ash/shelf/shelf_item_delegate_manager.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_widget.h"
@@ skipping 389 matching lines @@
     (*iter)->shelf()->CreateShelf();
 }
 
 void Shell::OnShelfCreatedForRootWindow(aura::Window* root_window) {
   FOR_EACH_OBSERVER(ShellObserver,
                     observers_,
                     OnShelfCreatedForRootWindow(root_window));
 }
 
 void Shell::CreateKeyboard() {
+  if (GetMojoShell())
+    return;
   // TODO(bshe): Primary root window controller may not be the controller to
   // attach virtual keyboard. See http://crbug.com/303429
   InitKeyboard();
   GetPrimaryRootWindowController()->
       ActivateKeyboard(keyboard::KeyboardController::GetInstance());
 }
 
 void Shell::DeactivateKeyboard() {
+  keyboard_ui_->Hide();
+  if (GetMojoShell())
+    return;
   if (keyboard::KeyboardController::GetInstance()) {
     RootWindowControllerList controllers = GetAllRootWindowControllers();
     for (RootWindowControllerList::iterator iter = controllers.begin();
         iter != controllers.end(); ++iter) {
       (*iter)->DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
     }
   }
   keyboard::KeyboardController::ResetInstance(nullptr);
 }
 
@@ skipping 573 matching lines @@
       base::Bind(&SystemTrayDelegate::SignOut,
                  base::Unretained(system_tray_delegate_.get()))));
 
   // Create TouchTransformerController before
   // WindowTreeHostManager::InitDisplays()
   // since TouchTransformerController listens on
   // WindowTreeHostManager::Observer::OnDisplaysInitialized().
   touch_transformer_controller_.reset(new TouchTransformerController());
 #endif  // defined(OS_CHROMEOS)
 
+  keyboard_ui_ = KeyboardUI::Create();
+

[sadrul, 2016/02/10 23:57:14]

I wonder if ShellInitParams could include a KeyboardUIFactory. If there's no
factory, Shell creates the default KeyboardUIImpl. //ash/mus/ can then provide a
factory to create KeyboardUIMus instead. With this approach, ash itself can
continue to be unaware of mus, and there's a clear separation of mus-ash vs
non-mus-ash.

[sky, 2016/02/11 00:39:47]

Both of your suggestions are certainly doable. If the long term goal were to
keep the two separate than I would agree we should do as you suggest. The long
term goal is to get rid of non-mus-ash though, so it seems like we may as well
bite the bullet. I tried to keep things nice and self contained here, but I
think other patches may not be as nice and it seems inevitable that we'll want
more knowledge of the environment we're in to make decisions. For example, we
shouldn't be compiling large parts of ash.

But, I suppose I can do as you suggest and we can cross that bridge when we get
to it. WDYT?

[sadrul, 2016/02/11 14:36:07]

Even in the complete mustash world, it would be pretty nice to have a separate
non-mus ash component. (But yeah, it would be 'nice', not necessarily
'essential')
Yep, sounds good. Thanks!

   window_tree_host_manager_->InitHosts();
 
 #if defined(OS_CHROMEOS)
   // Needs to be created after InitDisplays() since it may cause the virtual
   // keyboard to be deployed.
   virtual_keyboard_controller_.reset(new VirtualKeyboardController);
 #endif  // defined(OS_CHROMEOS)
 
   // It needs to be created after RootWindowController has been created
   // (which calls OnWindowResized has been called, otherwise the
@@ skipping 25 matching lines @@
   // order to create mirror window. Run it after the main message loop
   // is started.
   display_manager_->CreateMirrorWindowAsyncIfAny();
 
   FOR_EACH_OBSERVER(ShellObserver, observers_, OnShellInitialized());
 
   user_metrics_recorder_->OnShellInitialized();
 }
 
 void Shell::InitKeyboard() {
+  if (GetMojoShell())
+    return;

[sadrul, 2016/02/10 23:57:14]

Similarly, would it make sense to include a flag to ShellInitParams stating
whether ash is running inside mus or not? We could then use that flag to turn
off other systems inside of ash incrementally. Or we could also introduce
something to ViewsDelegate to know whether this is running inside of mus or not
(e.g. ViewsDelegate::IsRunningAsMusClient())

+
   if (keyboard::IsKeyboardEnabled()) {
     if (keyboard::KeyboardController::GetInstance()) {
       RootWindowControllerList controllers = GetAllRootWindowControllers();
       for (RootWindowControllerList::iterator iter = controllers.begin();
            iter != controllers.end(); ++iter) {
         (*iter)->DeactivateKeyboard(
             keyboard::KeyboardController::GetInstance());
       }
     }
     keyboard::KeyboardController::ResetInstance(
@@ skipping 67 matching lines @@
 
 void Shell::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (gained_active)
     target_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash