Only show virtual keyboard on primary root window

ui/keyboard/keyboard_controller.cc

 // Copyright (c) 2013 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 "ui/keyboard/keyboard_controller.h"
 
 #include "base/bind.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
@@ skipping 104 matching lines @@
 
  private:
   aura::Window* container_;
   aura::Window* keyboard_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardLayoutManager);
 };
 
 KeyboardController::KeyboardController(KeyboardControllerProxy* proxy)
     : proxy_(proxy),
-      container_(NULL),
       input_method_(NULL),
       keyboard_visible_(false),
       weak_factory_(this) {
   CHECK(proxy);
   input_method_ = proxy_->GetInputMethod();
   input_method_->AddObserver(this);
 }
 
 KeyboardController::~KeyboardController() {
-  if (container_)
+  if (container_.get())
     container_->RemoveObserver(this);
   if (input_method_)
     input_method_->RemoveObserver(this);
 }
 
 aura::Window* KeyboardController::GetContainerWindow() {
-  if (!container_) {
-    container_ = new aura::Window(new KeyboardWindowDelegate());
+  if (!container_.get()) {
+    container_.reset(new aura::Window(new KeyboardWindowDelegate()));
     container_->SetName("KeyboardContainer");
+    container_->set_owned_by_parent(false);
     container_->Init(ui::LAYER_NOT_DRAWN);
     container_->AddObserver(this);
-    container_->SetLayoutManager(new KeyboardLayoutManager(container_));
+    container_->SetLayoutManager(new KeyboardLayoutManager(container_.get()));
   }
-  return container_;
+  return container_.get();
 }
 
 void KeyboardController::HideKeyboard() {
   keyboard_visible_ = false;
 
   FOR_EACH_OBSERVER(KeyboardControllerObserver,
                     observer_list_,
                     OnKeyboardBoundsChanging(gfx::Rect()));
 
-  proxy_->HideKeyboardContainer(container_);
+  proxy_->HideKeyboardContainer(container_.get());
 }
 
 void KeyboardController::AddObserver(KeyboardControllerObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void KeyboardController::RemoveObserver(KeyboardControllerObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void KeyboardController::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
-  if (params.new_parent && params.target == container_)
+  if (params.new_parent && params.target == container_.get())
     OnTextInputStateChanged(proxy_->GetInputMethod()->GetTextInputClient());
 }
 
-void KeyboardController::OnWindowDestroying(aura::Window* window) {
-  DCHECK_EQ(container_, window);
-  container_ = NULL;
-}
-
 void KeyboardController::OnTextInputStateChanged(
     const ui::TextInputClient* client) {
-  if (!container_)
+  if (!container_.get())
     return;
 
   bool was_showing = keyboard_visible_;
   bool should_show = was_showing;
   ui::TextInputType type =
       client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
   if (type == ui::TEXT_INPUT_TYPE_NONE) {
     should_show = false;
   } else {
     if (container_->children().empty()) {
       aura::Window* keyboard = proxy_->GetKeyboardWindow();
       keyboard->Show();
       container_->AddChild(keyboard);
       container_->layout_manager()->OnWindowResized();
     }
     proxy_->SetUpdateInputType(type);
-    container_->parent()->StackChildAtTop(container_);
+    container_->parent()->StackChildAtTop(container_.get());
     should_show = true;
   }
 
   if (was_showing != should_show) {
     if (should_show) {
       keyboard_visible_ = true;
       weak_factory_.InvalidateWeakPtrs();
       if (container_->IsVisible())
         return;
 
       FOR_EACH_OBSERVER(
           KeyboardControllerObserver,
           observer_list_,
           OnKeyboardBoundsChanging(container_->children()[0]->bounds()));
-      proxy_->ShowKeyboardContainer(container_);
+      proxy_->ShowKeyboardContainer(container_.get());
     } else {
       // Set the visibility state here so that any queries for visibility
       // before the timer fires returns the correct future value.
       keyboard_visible_ = false;
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&KeyboardController::HideKeyboard,
                      weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kHideKeyboardDelayMs));
     }
   }
   // TODO(bryeung): whenever the TextInputClient changes we need to notify the
   // keyboard (with the TextInputType) so that it can reset it's state (e.g.
   // abandon compositions in progress)
 }
 
 void KeyboardController::OnInputMethodDestroyed(
     const ui::InputMethod* input_method) {
   DCHECK_EQ(input_method_, input_method);
   input_method_ = NULL;
 }
 
 bool KeyboardController::WillHideKeyboard() const {
   return weak_factory_.HasWeakPtrs();
 }
 
 }  // namespace keyboard