Fix the issue that GetFrameWindow() may change between AddObserver and RemoveObserver in KeyboardCo…

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 <set>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/hit_test.h"
@@ skipping 183 matching lines @@
     ui::LayerAnimationSequence* seq) {
   animator_->RemoveObserver(this);
 }
 
 class WindowBoundsChangeObserver : public aura::WindowObserver {
  public:
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE;
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+
+  void AddObservedWindow(aura::Window* window);
+  void RemoveAllObservedWindows();
+
+ private:
+  std::set<aura::Window*> observed_windows_;
 };
 
 void WindowBoundsChangeObserver::OnWindowBoundsChanged(aura::Window* window,
     const gfx::Rect& old_bounds, const gfx::Rect& new_bounds) {
   KeyboardController* controller =  KeyboardController::GetInstance();
   if (controller)
     controller->UpdateWindowInsets(window);
 }
 
 void WindowBoundsChangeObserver::OnWindowDestroyed(aura::Window* window) {
    if (window->HasObserver(this))
      window->RemoveObserver(this);

[kevers, 2014/09/02 14:32:30]

observed_windows_.erase(window);

Otherwise RemoveAllObservedWindows could attempt to remove an observer from a
window that has already been destroyed.

[Shu Chen, 2014/09/02 14:33:20]

Done.

 }
 
+void WindowBoundsChangeObserver::AddObservedWindow(aura::Window* window) {
+  if (!window->HasObserver(this)) {
+    window->AddObserver(this);
+    observed_windows_.insert(window);
+  }
+}
+
+void WindowBoundsChangeObserver::RemoveAllObservedWindows() {
+  for (std::set<aura::Window*>::iterator it = observed_windows_.begin();
+       it != observed_windows_.end(); ++it)
+    (*it)->RemoveObserver(this);
+  observed_windows_.clear();
+}
+
 // static
 KeyboardController* KeyboardController::instance_ = NULL;
 
 KeyboardController::KeyboardController(KeyboardControllerProxy* proxy)
     : proxy_(proxy),
       input_method_(NULL),
       keyboard_visible_(false),
       show_on_resize_(false),
       lock_keyboard_(false),
       type_(ui::TEXT_INPUT_TYPE_NONE),
@@ skipping 292 matching lines @@
     container_->layer()->SetOpacity(1.0);
   }
 }
 
 void KeyboardController::ResetWindowInsets() {
   const gfx::Insets insets;
   scoped_ptr<content::RenderWidgetHostIterator> widgets(
       content::RenderWidgetHost::GetRenderWidgetHosts());
   while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
     content::RenderWidgetHostView* view = widget->GetView();
-    if (view) {
+    if (view)
       view->SetInsets(insets);
-      aura::Window *window = view->GetNativeView();
-      RemoveBoundsChangedObserver(window);
-    }
   }
+  window_bounds_observer_->RemoveAllObservedWindows();
 }
 
 bool KeyboardController::WillHideKeyboard() const {
   return weak_factory_.HasWeakPtrs();
 }
 
 void KeyboardController::ShowAnimationFinished() {
   // Notify observers after animation finished to prevent reveal desktop
   // background during animation.
   NotifyKeyboardBoundsChanging(proxy_->GetKeyboardWindow()->bounds());
   proxy_->EnsureCaretInWorkArea();
 }
 
 void KeyboardController::HideAnimationFinished() {
   proxy_->HideKeyboardContainer(container_.get());
 }
 
 void KeyboardController::AddBoundsChangedObserver(aura::Window* window) {
   aura::Window* target_window = GetFrameWindow(window);
-  if (target_window &&
-      !target_window->HasObserver(window_bounds_observer_.get())) {
-    target_window->AddObserver(window_bounds_observer_.get());
-  }
-}
-
-void KeyboardController::RemoveBoundsChangedObserver(aura::Window* window) {
-  aura::Window* target_window = GetFrameWindow(window);
-  if (target_window &&
-      target_window->HasObserver(window_bounds_observer_.get())) {
-    target_window->RemoveObserver(window_bounds_observer_.get());
-  }
+  if (target_window)
+    window_bounds_observer_->AddObservedWindow(target_window);
 }
 
 }  // namespace keyboard