Updates the histograms for IMF and IMEs according to the new design.

chrome/browser/chromeos/input_method/input_method_manager_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include <algorithm>  // std::find
 
 #include <sstream>
 
 #include "ash/ime/input_method_menu_item.h"
 #include "ash/ime/input_method_menu_manager.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/input_method/candidate_window_controller.h"
 #include "chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/language_preferences.h"
@@ skipping 16 matching lines @@
 namespace input_method {
 
 namespace {
 
 bool Contains(const std::vector<std::string>& container,
               const std::string& value) {
   return std::find(container.begin(), container.end(), value) !=
       container.end();
 }
 
+enum InputMethodCategory {
+  INPUT_METHOD_CATEGORY_UNK = 0,
+  INPUT_METHOD_CATEGORY_XKB,
+  INPUT_METHOD_CATEGORY_ZH,
+  INPUT_METHOD_CATEGORY_JA,
+  INPUT_METHOD_CATEGORY_KO,
+  INPUT_METHOD_CATEGORY_M17N,
+  INPUT_METHOD_CATEGORY_T13N,
+  INPUT_METHOD_CATEGORY_MAX

[Ilya Sherman, 2014/09/16 00:00:28]

nit: I find these names needlessly cryptic.  Would it be reasonable to use less
cryptic names?  If not, please at least add comments to provide documentation.

[Shu Chen, 2014/09/16 16:36:30]

Done. I've added comments.

+};
+
+InputMethodCategory GetInputMethodCategory(const std::string& input_method_id,
+                                           char* first_char = NULL) {
+  const std::string component_id =
+      extension_ime_util::GetComponentIDByInputMethodID(input_method_id);
+  InputMethodCategory category = INPUT_METHOD_CATEGORY_UNK;
+  char ch = 0;
+  if (StartsWithASCII(component_id, "xkb:", true)) {
+    ch = component_id[4];
+    category = INPUT_METHOD_CATEGORY_XKB;
+  } else if (StartsWithASCII(component_id, "zh-", true)) {
+    size_t pos = component_id.find("-t-i0-");
+    if (pos > 0)
+      pos += 6;
+    ch = component_id[pos];
+    category = INPUT_METHOD_CATEGORY_ZH;
+  } else if (StartsWithASCII(component_id, "nacl_mozc_", true)) {
+    ch = component_id[10];
+    category = INPUT_METHOD_CATEGORY_JA;
+  } else if (StartsWithASCII(component_id, "hangul_", true)) {
+    ch = component_id[7];
+    category = INPUT_METHOD_CATEGORY_KO;
+  } else if (StartsWithASCII(component_id, "vkd_", true)) {
+    ch = component_id[4];
+    category = INPUT_METHOD_CATEGORY_M17N;
+  } else if (component_id.find("-t-i0-") > 0) {
+    ch = component_id[0];
+    category = INPUT_METHOD_CATEGORY_T13N;
+  }
+
+  if (first_char)
+    *first_char = ch;
+  return category;
+}
+
 }  // namespace
 
 // ------------------------ InputMethodManagerImpl::StateImpl
 
 InputMethodManagerImpl::StateImpl::StateImpl(InputMethodManagerImpl* manager,
                                              Profile* profile)
     : profile(profile), manager_(manager) {
 }
 
 InputMethodManagerImpl::StateImpl::~StateImpl() {
@@ skipping 259 matching lines @@
       new_active_input_method_ids_filtered.push_back(input_method_id);
   }
   active_input_method_ids.swap(new_active_input_method_ids_filtered);
   manager_->MigrateInputMethods(&active_input_method_ids);
 
   manager_->ReconfigureIMFramework(this);
 
   // If |current_input_method| is no longer in |active_input_method_ids|,
   // ChangeInputMethod() picks the first one in |active_input_method_ids|.
   ChangeInputMethod(current_input_method.id(), false);
+
+  // Record histogram for active input method count.
+  UMA_HISTOGRAM_COUNTS("InputMethod.ActiveCount",
+                       active_input_method_ids.size());
+
   return true;
 }
 
 void InputMethodManagerImpl::StateImpl::ChangeInputMethod(
     const std::string& input_method_id,
     bool show_message) {
   if (manager_->ui_session_ == STATE_TERMINATING)
     return;
 
   bool notify_menu = false;
@@ skipping 13 matching lines @@
   if (descriptor->id() != current_input_method.id()) {
     previous_input_method = current_input_method;
     current_input_method = *descriptor;
     notify_menu = true;
   }
 
   // Always change input method even if it is the same.
   // TODO(komatsu): Revisit if this is neccessary.
   if (IsActive())
     manager_->ChangeInputMethodInternal(*descriptor, show_message, notify_menu);
+  manager_->RecordInputMethodUsage(current_input_method.id());
 }
 
 bool InputMethodManagerImpl::StateImpl::MethodAwaitsExtensionLoad(
     const std::string& input_method_id) const {
   // For 3rd party IME, when the user just logged in, SetEnabledExtensionImes
   // happens after activating the 3rd party IME.
   // So here to record the 3rd party IME to be activated, and activate it
   // when SetEnabledExtensionImes happens later.
   return !InputMethodIsActivated(input_method_id) &&
          extension_ime_util::IsExtensionIME(input_method_id);
@@ skipping 400 matching lines @@
 }
 
 InputMethodManagerImpl::InputMethodManagerImpl(
     scoped_ptr<InputMethodDelegate> delegate,
     bool enable_extension_loading)
     : delegate_(delegate.Pass()),
       ui_session_(STATE_LOGIN_SCREEN),
       state_(NULL),
       util_(delegate_.get()),
       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
-      enable_extension_loading_(enable_extension_loading) {
+      enable_extension_loading_(enable_extension_loading),
+      stat_id_histogram_(NULL) {
   if (base::SysInfo::IsRunningOnChromeOS())
     keyboard_.reset(ImeKeyboard::Create());
   else
     keyboard_.reset(new FakeImeKeyboard());
 
   // Initializes the system IME list.
   scoped_ptr<ComponentExtensionIMEManagerDelegate> comp_delegate(
       new ComponentExtensionIMEManagerImpl());
   component_extension_ime_manager_->Initialize(comp_delegate.Pass());
-  util_.ResetInputMethods(
-      component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor());
+  const InputMethodDescriptors& descriptors =
+      component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor();
+  util_.ResetInputMethods(descriptors);
+
+  // Initializes the stat id map.
+  std::map<int, std::vector<std::string> > buckets;
+  for (InputMethodDescriptors::const_iterator it = descriptors.begin();
+       it != descriptors.end(); ++it) {
+    char first_char;
+    int cat_id = static_cast<int>(
+        GetInputMethodCategory(it->id(), &first_char));
+    int key = cat_id * 1000 + first_char;
+    buckets[key].push_back(it->id());
+  }
+  std::vector<int> stat_id_custom_ranges;
+  for (std::map<int, std::vector<std::string>>::iterator i =
+       buckets.begin(); i != buckets.end(); ++i) {
+    std::sort(i->second.begin(), i->second.end());
+    for (size_t j = 0; j < i->second.size(); ++j) {
+      int key = i->first * 100 + j;
+      stat_id_map_[i->second[j]] = key;
+      stat_id_custom_ranges.push_back(key);
+      stat_id_custom_ranges.push_back(key + 1);
+    }
+  }
+  stat_id_histogram_ = base::CustomHistogram::FactoryGet(
+      "InputMethod.ID", stat_id_custom_ranges,
+      base::HistogramBase::kUmaTargetedHistogramFlag);

[Ilya Sherman, 2014/09/16 00:00:28]

Hmm, why do you capture this reference, rather than using a macro?  I don't
fully understand what the IDs you're trying to emit are; but I bet that a sparse
histogram would work nicely for your needs.

[Shu Chen, 2014/09/16 16:36:29]

Done.

 }
 
 InputMethodManagerImpl::~InputMethodManagerImpl() {
   if (candidate_window_controller_.get())
     candidate_window_controller_->RemoveObserver(this);
 }
 
+void InputMethodManagerImpl::RecordInputMethodUsage(
+    std::string input_method_id) {
+  UMA_HISTOGRAM_ENUMERATION("InputMethod.Category",
+                            GetInputMethodCategory(input_method_id),
+                            INPUT_METHOD_CATEGORY_MAX);
+  stat_id_histogram_->Add(stat_id_map_[input_method_id]);
+}
+
 void InputMethodManagerImpl::AddObserver(
     InputMethodManager::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void InputMethodManagerImpl::AddCandidateWindowObserver(
     InputMethodManager::CandidateWindowObserver* observer) {
   candidate_window_observers_.AddObserver(observer);
 }
 
@@ skipping 241 matching lines @@
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 }  // namespace input_method
 }  // namespace chromeos