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
+    // observers to do so for performance reasons.

[satorux1, 2010/12/01 07:56:47]

You could elaborate a bit more:

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.

[Yusuke Sato, 2010/12/01 09:21:25]

Done.

+    ObserverListBase<Observer>::Iterator it(observers_);
+    Observer* first_observer;

[satorux1, 2010/12/01 07:56:47]

Uninitialized pointers annoy me. :) The following would be a bit nicer.

Observer* first_observer = it.GetNext();
if (first_observer != NULL) {
  ...

[Yusuke Sato, 2010/12/01 09:21:25]

Done.

+    if ((first_observer = it.GetNext()) != NULL) {
+      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);