Prevent initialization of the Input Method Manager after the APP_TERMINATING message has been sent.

chrome/browser/chromeos/input_method/input_method_manager.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/input_method/input_method_manager.h"
 
 #include <algorithm>
 
 #include <glib.h>
 
@@ skipping 57 matching lines @@
  public:
   InputMethodManagerImpl()
       : ibus_controller_(NULL),
         should_launch_ime_(false),
         ime_connected_(false),
         defer_ime_startup_(false),
         enable_auto_ime_shutdown_(true),
 #if !defined(TOUCH_UI)
         candidate_window_controller_(NULL),
 #endif
+        shutting_down_(false),
         ibus_daemon_process_handle_(base::kNullProcessHandle) {
     // Observe APP_TERMINATING to stop input method daemon gracefully.
     // We should not use APP_EXITING here since logout might be canceled by
     // JavaScript after APP_EXITING is sent (crosbug.com/11055).
     // Note that even if we fail to stop input method daemon from
     // Chrome in case of a sudden crash, we have a way to do it from an
     // upstart script. See crosbug.com/6515 and crosbug.com/6995 for
     // details.
     notification_registrar_.Add(this, content::NOTIFICATION_APP_TERMINATING,
                                 NotificationService::AllSources());
@@ skipping 737 matching lines @@
   // Launches input method daemon if these are not yet running. Returns true if
   // the daemon is started. Otherwise, e.g. the daemon is already started,
   // returns false.
   bool MaybeLaunchInputMethodDaemon() {
     // CandidateWindowController requires libcros to be loaded. Besides,
     // launching ibus-daemon without libcros loaded doesn't make sense.
     if (!should_launch_ime_) {
       return false;
     }
 
+    if (shutting_down_) {
+      NOTREACHED() << "Trying to launch input method while shutting down";
+      return false;
+    }
+
 #if !defined(TOUCH_UI)
     if (!candidate_window_controller_.get()) {
       candidate_window_controller_.reset(
           new input_method::CandidateWindowController);
       if (!candidate_window_controller_->Init()) {
         LOG(WARNING) << "Failed to initialize the candidate window controller";
       }
     }
 #endif
 
@@ skipping 52 matching lines @@
   void SetEnableAutoImeShutdown(bool enable) {
     enable_auto_ime_shutdown_ = enable;
   }
 
   // NotificationObserver implementation:
   void Observe(int type,
                const NotificationSource& source,
                const NotificationDetails& details) {
     // Stop the input method daemon on browser shutdown.
     if (type == content::NOTIFICATION_APP_TERMINATING) {
+      shutting_down_ = true;
       notification_registrar_.RemoveAll();
       StopInputMethodDaemon();
 #if !defined(TOUCH_UI)
       candidate_window_controller_.reset(NULL);
 #endif
     }
   }
 
   // A reference to the language api, to allow callbacks when the input method
   // status changes.
@@ skipping 42 matching lines @@
   // TODO(yusukes): clear this variable when a user logs in.
   std::string tentative_current_input_method_id_;
 
   // The candidate window.  This will be deleted when the APP_TERMINATING
   // message is sent.
 #if !defined(TOUCH_UI)
   scoped_ptr<input_method::CandidateWindowController>
       candidate_window_controller_;
 #endif
 
+  // True if we've received the APP_TERMINATING notification.
+  bool shutting_down_;
+
   // The process handle of the IBus daemon. kNullProcessHandle if it's not
   // running.
   base::ProcessHandle ibus_daemon_process_handle_;
 
   // An object which keeps a list of available virtual keyboards.
   input_method::VirtualKeyboardSelector virtual_keyboard_selector_;
 
   // The active input method ids cache.
   std::vector<std::string> active_input_method_ids_;
 
@@ skipping 10 matching lines @@
   return InputMethodManagerImpl::GetInstance();
 }
 
 }  // namespace input_method
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     chromeos::input_method::InputMethodManagerImpl);