Add login screen locale and input method device policies

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 <stdint.h>
 
 #include <algorithm>  // std::find
 #include <memory>
@@ skipping 112 matching lines @@
   previous_input_method = other.previous_input_method;
   current_input_method = other.current_input_method;
 
   active_input_method_ids = other.active_input_method_ids;
 
   pending_input_method_id = other.pending_input_method_id;
 
   enabled_extension_imes = other.enabled_extension_imes;
   extra_input_methods = other.extra_input_methods;
   menu_activated = other.menu_activated;
+  allowed_keyboard_layout_input_method_ids =
+      other.allowed_keyboard_layout_input_method_ids;
 }
 
 bool InputMethodManagerImpl::StateImpl::IsActive() const {
   return manager_->state_.get() == this;
 }
 
 std::string InputMethodManagerImpl::StateImpl::Dump() const {
   std::ostringstream os;
 
   os << "################# "
@@ skipping 105 matching lines @@
   candidates.insert(candidates.end(), layouts_from_locale.begin(),
                     layouts_from_locale.end());
 
   std::vector<std::string> layouts;
   // First, add the initial input method ID, if it's requested, to
   // layouts, so it appears first on the list of active input
   // methods at the input language status menu.
   for (size_t i = 0; i < initial_layouts.size(); ++i) {
     if (manager_->util_.IsValidInputMethodId(initial_layouts[i])) {
       if (manager_->IsLoginKeyboard(initial_layouts[i])) {
-        layouts.push_back(initial_layouts[i]);
+        if (IsInputMethodAllowed(initial_layouts[i])) {
+          layouts.push_back(initial_layouts[i]);
+        } else {
+          DVLOG(1) << "EnableLoginLayouts: ignoring layout disallowd by policy:"
+                   << initial_layouts[i];
+        }
       } else {
         DVLOG(1)
             << "EnableLoginLayouts: ignoring non-login initial keyboard layout:"
             << initial_layouts[i];
       }
     } else if (!initial_layouts[i].empty()) {
       DVLOG(1) << "EnableLoginLayouts: ignoring non-keyboard or invalid ID: "
                << initial_layouts[i];
     }
   }
 
   // Add candidates to layouts, while skipping duplicates.
   for (size_t i = 0; i < candidates.size(); ++i) {
     const std::string& candidate = candidates[i];
     // Not efficient, but should be fine, as the two vectors are very
     // short (2-5 items).
-    if (!Contains(layouts, candidate) && manager_->IsLoginKeyboard(candidate))
+    if (!Contains(layouts, candidate) && manager_->IsLoginKeyboard(candidate) &&
+        IsInputMethodAllowed(candidate)) {
       layouts.push_back(candidate);
+    }
   }
 
   manager_->MigrateInputMethods(&layouts);
   active_input_method_ids.swap(layouts);
 
   if (IsActive()) {
     // Initialize candidate window controller and widgets such as
     // candidate window, infolist and mode indicator.  Note, mode
     // indicator is used by only keyboard layout input methods.
     if (active_input_method_ids.size() > 1)
@@ skipping 40 matching lines @@
   active_input_method_ids.swap(new_active_input_method_ids);
 
   // Re-check current_input_method.
   ChangeInputMethod(current_input_method.id(), false);
 }
 
 // Adds new input method to given list.
 bool InputMethodManagerImpl::StateImpl::EnableInputMethodImpl(
     const std::string& input_method_id,
     std::vector<std::string>* new_active_input_method_ids) const {
+  if (!IsInputMethodAllowed(input_method_id)) {
+    DVLOG(1) << "EnableInputMethod: " << input_method_id << " is not allowed.";
+    return false;
+  }
+
   DCHECK(new_active_input_method_ids);
   if (!manager_->util_.IsValidInputMethodId(input_method_id)) {
     DVLOG(1) << "EnableInputMethod: Invalid ID: " << input_method_id;
     return false;
   }
 
   if (!Contains(*new_active_input_method_ids, input_method_id))
     new_active_input_method_ids->push_back(input_method_id);
 
   return true;
@@ skipping 41 matching lines @@
   // 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;
 }
 
+bool InputMethodManagerImpl::StateImpl::SetAllowedInputMethods(
+    const std::vector<std::string>& new_allowed_input_method_ids) {
+  allowed_keyboard_layout_input_method_ids.clear();
+  for (auto input_method_id : new_allowed_input_method_ids) {
+    std::string migrated_id =
+        manager_->util_.MigrateInputMethod(input_method_id);
+    if (manager_->util_.IsValidInputMethodId(migrated_id)) {
+      allowed_keyboard_layout_input_method_ids.push_back(migrated_id);
+    }
+  }
+
+  if (allowed_keyboard_layout_input_method_ids.empty()) {
+    // None of the passed input methods were valid, so allow everything.
+    return false;
+  }
+
+  // Enable all allowed keyboard layout input methods. Leave all non-keyboard
+  // input methods enabled.
+  std::vector<std::string> new_active_input_method_ids(
+      allowed_keyboard_layout_input_method_ids);
+  for (auto active_input_method_id : active_input_method_ids) {
+    if (!manager_->util_.IsKeyboardLayout(active_input_method_id))
+      new_active_input_method_ids.push_back(active_input_method_id);
+  }
+  return ReplaceEnabledInputMethods(new_active_input_method_ids);
+}
+
+const std::vector<std::string>&
+InputMethodManagerImpl::StateImpl::GetAllowedInputMethods() {
+  return allowed_keyboard_layout_input_method_ids;
+}
+
+bool InputMethodManagerImpl::StateImpl::IsInputMethodAllowed(
+    const std::string& input_method_id) const {
+  // Every input method is allowed if SetAllowedKeyboardLayoutInputMethods has
+  // not been called.
+  if (allowed_keyboard_layout_input_method_ids.empty())
+    return true;
+
+  // We only restrict keyboard layouts.
+  if (!manager_->util_.IsKeyboardLayout(input_method_id))
+    return true;
+
+  return Contains(allowed_keyboard_layout_input_method_ids, input_method_id) ||
+         Contains(allowed_keyboard_layout_input_method_ids,
+                  manager_->util_.MigrateInputMethod(input_method_id));
+}
+
 void InputMethodManagerImpl::StateImpl::ChangeInputMethod(
     const std::string& input_method_id,
     bool show_message) {
   if (manager_->ui_session_ == STATE_TERMINATING)
     return;
 
   bool notify_menu = false;
 
   // Always lookup input method, even if it is the same as
   // |current_input_method| because If it is no longer in
@@ skipping 857 matching lines @@
   if (keyboard_controller)
     keyboard_controller->Reload();
 }
 
 bool InputMethodManagerImpl::IsEmojiHandwritingVoiceOnImeMenuEnabled() {
   return base::FeatureList::IsEnabled(features::kEHVInputOnImeMenu);
 }
 
 }  // namespace input_method
 }  // namespace chromeos