Only show virtual keyboard on primary root window

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 "ash/accelerators/accelerator_controller.h"
@@ skipping 75 matching lines @@
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
 #include "ui/keyboard/keyboard.h"
+#include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/message_center/message_center.h"
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/views/corewm/corewm_switches.h"
 #include "ui/views/corewm/focus_controller.h"
 #include "ui/views/corewm/input_method_event_filter.h"
 #include "ui/views/corewm/shadow_controller.h"
 #include "ui/views/corewm/tooltip_controller.h"
 #include "ui/views/corewm/visibility_controller.h"
 #include "ui/views/corewm/window_modality_controller.h"
@@ skipping 45 matching lines @@
 }  // namespace
 
 // static
 Shell* Shell::instance_ = NULL;
 // static
 bool Shell::initially_hide_cursor_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(ShellDelegate* delegate)

[varkha, 2013/10/04 01:54:07]

Ctor is private. Also verify that the methods are in the same order as in the
header - they seem to have diverged.

[bshe, 2013/10/04 03:04:39]

Done.

     : screen_(new ScreenAsh),
       target_root_window_(NULL),
       scoped_target_root_window_(NULL),
       delegate_(delegate),
       activation_client_(NULL),
 #if defined(OS_CHROMEOS) && defined(USE_X11)
       output_configurator_(new chromeos::OutputConfigurator()),
 #endif  // defined(OS_CHROMEOS)
       native_cursor_manager_(new AshNativeCursorManager),
       cursor_manager_(scoped_ptr<views::corewm::NativeCursorManager>(
@@ skipping 219 matching lines @@
   }
   return containers;
 }
 
 // static
 bool Shell::IsForcedMaximizeMode() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kForcedMaximizeMode);
 }
 
 void Shell::Init() {

[varkha, 2013/10/04 01:54:07]

Should go down in private: section.

[bshe, 2013/10/04 03:04:39]

Done.

   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   delegate_->PreInit();
   bool display_initialized = false;
 #if defined(OS_CHROMEOS) && defined(USE_X11)
   output_configurator_animation_.reset(
       new internal::OutputConfiguratorAnimation());
   output_configurator_->AddObserver(output_configurator_animation_.get());
   if (base::SysInfo::IsRunningOnChromeOS()) {
     display_change_observer_.reset(new internal::DisplayChangeObserver);
@@ skipping 139 matching lines @@
   system_tray_notifier_.reset(new ash::SystemTrayNotifier());
 
   // Initialize system_tray_delegate_ before initializing StatusAreaWidget.
   system_tray_delegate_.reset(delegate()->CreateSystemTrayDelegate());
   DCHECK(system_tray_delegate_.get());
 
   internal::RootWindowController* root_window_controller =
       new internal::RootWindowController(root_window);
   InitRootWindowController(root_window_controller,
                            delegate_->IsFirstRunAfterBoot());
+  InitKeyboard(root_window_controller);
 
   locale_notification_controller_.reset(
       new internal::LocaleNotificationController);
 
   // Initialize system_tray_delegate_ after StatusAreaWidget is created.
   system_tray_delegate_->Initialize();
 
   display_controller_->InitSecondaryDisplays();
 
   // Force Layout
@@ skipping 107 matching lines @@
                                      const gfx::Insets& insets) {
   if (!display_controller_->UpdateWorkAreaOfDisplayNearestWindow(
           contains, insets)) {
     return;
   }
   FOR_EACH_OBSERVER(ShellObserver, observers_,
                     OnDisplayWorkAreaInsetsChanged());
 }
 
 void Shell::OnLoginStateChanged(user::LoginStatus status) {
+  if (status != user::LOGGED_IN_NONE) {
+    // TODO(bshe): Primary root window controller may not be the controller to
+    // attach virtual keyboard. See http://crbug.com/303429
+    InitKeyboard(GetPrimaryRootWindowController());
+  }
   FOR_EACH_OBSERVER(ShellObserver, observers_, OnLoginStateChanged(status));
 }
 
 void Shell::UpdateAfterLoginStatusChange(user::LoginStatus status) {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->UpdateAfterLoginStatusChange(status);
 }
 
@@ skipping 163 matching lines @@
   // Create a launcher if a user is already logged.
   if (Shell::GetInstance()->session_state_delegate()->NumberOfLoggedInUsers())
     controller->shelf()->CreateLauncher();
 }
 
 void Shell::DoInitialWorkspaceAnimation() {
   return GetPrimaryRootWindowController()->workspace_controller()->
       DoInitialAnimation();
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Shell, private:
+
+void Shell::InitKeyboard(internal::RootWindowController* root) {
+  if (keyboard::IsKeyboardEnabled()) {
+    if (keyboard_controller_.get()) {
+      RootWindowControllerList controllers = GetAllRootWindowControllers();
+      for (RootWindowControllerList::iterator iter = controllers.begin();
+         iter != controllers.end(); ++iter) {

[varkha, 2013/10/04 01:54:07]

nit: align with RootWindowControllerList above.

[bshe, 2013/10/04 03:04:39]

Done.

+        (*iter)->DisableKeyboard(keyboard_controller_.get());

[varkha, 2013/10/04 01:54:07]

Can there be a situation when you are disabling keyboard here in some root only
to enable it below? If so, consider skipping it in the loop and then skipping
the EnableKeyboard call (unless there is some positive side effect from
disabling and re-enabling the keyboard in the same root.

[bshe, 2013/10/04 03:04:39]

We reset the keyboard controller before we enable keyboard controller again.
When keyboard controller got reset, the old keyboard container is deleted and a
new one should be created. This is mainly for reload keyboard upon user login.
We want to recreate keyboard controller and keyboard container. 

On 2013/10/04 01:54:07, varkha wrote:

+      }
+    }
+    keyboard::KeyboardControllerProxy* proxy =
+        delegate_->CreateKeyboardControllerProxy();
+    keyboard_controller_.reset(
+        new keyboard::KeyboardController(proxy));
+    root->EnableKeyboard(keyboard_controller_.get());
+  }
+}
+
 void Shell::InitRootWindowController(
     internal::RootWindowController* controller,
     bool first_run_after_boot) {
 
   aura::RootWindow* root_window = controller->root_window();
   DCHECK(activation_client_);
   DCHECK(visibility_controller_.get());
   DCHECK(drag_drop_controller_.get());
   DCHECK(window_cycle_controller_.get());
 
@@ skipping 14 matching lines @@
   if (nested_dispatcher_controller_) {
     aura::client::SetDispatcherClient(root_window,
                                       nested_dispatcher_controller_.get());
   }
   if (user_action_client_)
     aura::client::SetUserActionClient(root_window, user_action_client_.get());
 
   controller->Init(first_run_after_boot);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Shell, private:
-
 bool Shell::CanWindowReceiveEvents(aura::Window* window) {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter) {
     internal::SystemModalContainerLayoutManager* layout_manager =
         (*iter)->GetSystemModalLayoutManager(window);
     if (layout_manager && layout_manager->CanWindowReceiveEvents(window))
       return true;
   }
   return false;
@@ skipping 16 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, aura::client::ActivationChangeObserver implementation:
 
 void Shell::OnWindowActivated(aura::Window* gained_active,
                               aura::Window* lost_active) {
   if (gained_active)
     target_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash