Reduce CPU usage for input method switching.

chrome/browser/chromeos/cros/input_method_library.cc

 // Copyright (c) 2010 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/cros/input_method_library.h"
 
 #include <glib.h>
 #include <signal.h>
 
 #include "unicode/uloc.h"
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/keyboard_library.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 
 namespace {
+
 const char kIBusDaemonPath[] = "/usr/bin/ibus-daemon";
 const char kCandidateWindowPath[] = "/opt/google/chrome/candidate_window";
 
 // Finds a property which has |new_prop.key| from |prop_list|, and replaces the
 // property with |new_prop|. Returns true if such a property is found.
 bool FindAndUpdateProperty(const chromeos::ImeProperty& new_prop,
                            chromeos::ImePropertyList* prop_list) {
   for (size_t i = 0; i < prop_list->size(); ++i) {
     chromeos::ImeProperty& prop = prop_list->at(i);
     if (prop.key == new_prop.key) {
@@ skipping 247 matching lines @@
     if (pending_config_requests_.empty()) {
       timer_.Stop();  // no-op if it's not running.
     } else if (!timer_.IsRunning()) {
       // Flush is not completed. Start a timer if it's not yet running.
       static const int64 kTimerIntervalInMsec = 100;
       timer_.Start(base::TimeDelta::FromMilliseconds(kTimerIntervalInMsec),
                    this, &InputMethodLibraryImpl::FlushImeConfig);
     }
 
     if (active_input_methods_are_changed) {
-      FOR_EACH_OBSERVER(Observer, observers_, ActiveInputMethodsChanged(this));
+      const size_t num_active_input_methods = GetNumActiveInputMethods();
+      FOR_EACH_OBSERVER(Observer, observers_,
+                        ActiveInputMethodsChanged(this,
+                                                  current_input_method_,
+                                                  num_active_input_methods));
     }
   }
 
   static void InputMethodChangedHandler(
       void* object,
       const chromeos::InputMethodDescriptor& current_input_method) {
     // The handler is called when the input method method change is
     // notified via a DBus connection. Since the DBus notificatiosn are
     // handled in the UI thread, we can assume that this functionalways
     // runs on the UI thread, but just in case.
@@ skipping 75 matching lines @@
 
   void ChangeCurrentInputMethod(const InputMethodDescriptor& new_input_method) {
     // Change the keyboard layout to a preferred layout for the input method.
     CrosLibrary::Get()->GetKeyboardLibrary()->SetCurrentKeyboardLayoutByName(
         new_input_method.keyboard_layout);
 
     if (current_input_method_.id != new_input_method.id) {
       previous_input_method_ = current_input_method_;
       current_input_method_ = new_input_method;
     }
-    FOR_EACH_OBSERVER(Observer, observers_, InputMethodChanged(this));
+    const size_t num_active_input_methods = GetNumActiveInputMethods();
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      InputMethodChanged(this,
+                                         previous_input_method_,
+                                         current_input_method_,
+                                         num_active_input_methods));
+
+    // Ask the first observer to update preferences. We should not ask every
+    // observer to do so. Otherwise, we'll end up updating preferences many
+    // times when many observers are attached (ex. many windows are opened),
+    // which is unnecessary and expensive.
+    ObserverListBase<Observer>::Iterator it(observers_);
+    Observer* first_observer = it.GetNext();
+    if (first_observer) {
+      first_observer->PreferenceUpdateNeeded(this,
+                                             previous_input_method_,
+                                             current_input_method_);
+    }
   }
 
   void RegisterProperties(const ImePropertyList& prop_list) {
     // |prop_list| might be empty. This means "clear all properties."
     current_ime_properties_ = prop_list;
-    FOR_EACH_OBSERVER(Observer, observers_, ImePropertiesChanged(this));
   }
 
   void StartInputMethodProcesses() {
     should_launch_ime_ = true;
     MaybeLaunchInputMethodProcesses();
   }
 
   void UpdateProperty(const ImePropertyList& prop_list) {
     for (size_t i = 0; i < prop_list.size(); ++i) {
       FindAndUpdateProperty(prop_list[i], &current_ime_properties_);
     }
-    FOR_EACH_OBSERVER(Observer, observers_, ImePropertiesChanged(this));
   }
 
   // Launches an input method procsess specified by the given command
   // line. On success, returns true and stores the process ID in
   // |process_id|. Otherwise, returns false, and the contents of
   // |process_id| is untouched. OnImeShutdown will be called when the
   // process terminates.
   bool LaunchInputMethodProcess(const std::string& command_line,
                                 int* process_id) {
     GError *error = NULL;
@@ skipping 370 matching lines @@
     return new InputMethodLibraryStubImpl();
   else
     return new InputMethodLibraryImpl();
 }
 
 }  // 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::InputMethodLibraryImpl);