Allow input.ime.activate() to be called from a non-user-action for the first time.

chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc

 // Copyright 2015 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.
 
 // This file is for non-chromeos (win & linux) functions, such as
 // chrome.input.ime.activate, chrome.input.ime.createWindow and
 // chrome.input.ime.onSelectionChanged.
 // TODO(azurewei): May refactor the code structure by using delegate or
 // redesign the API to remove this platform-specific file in the future.
 
@@ skipping 28 matching lines @@
 const char kErrorNoActiveEngine[] = "The extension has not been activated.";
 const char kErrorPermissionDenied[] = "User denied permission.";
 const char kErrorCouldNotFindActiveBrowser[] =
     "Cannot find the active browser.";
 const char kErrorNotCalledFromUserAction[] =
     "This API is only allowed to be called from a user action.";
 
 // A preference determining whether to hide the warning bubble next time.
 const char kPrefWarningBubbleNeverShow[] = "skip_ime_warning_bubble";
 
+// A preference to see whether it is the first time to call input.ime.activate
+// since the extension is loaded.
+const char kPrefImeActivatedCalledBefore[] = "ime_activate_called_before";
+
 bool IsInputImeEnabled() {
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableInputImeAPI);
 }
 
 class ImeObserverNonChromeOS : public ui::ImeObserver {
  public:
   ImeObserverNonChromeOS(const std::string& extension_id, Profile* profile)
       : ImeObserver(extension_id, profile) {}
 
@@ skipping 57 matching lines @@
       event_router ? static_cast<InputMethodEngine*>(
                          event_router->GetActiveEngine(extension_id))
                    : nullptr;
   return engine;
 }
 
 void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
                                     const Extension* extension) {
   // No-op if called multiple times.
   ui::IMEBridge::Initialize();
+  Profile* profile = Profile::FromBrowserContext(browser_context);
+  ExtensionPrefs::Get(profile)->UpdateExtensionPref(
+      extension->id(), kPrefImeActivatedCalledBefore,
+      new base::FundamentalValue(false));
 }
 
 void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
                                       UnloadedExtensionInfo::Reason reason) {
   InputImeEventRouter* event_router =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context));
   if (event_router)
     event_router->DeleteInputMethodEngine(extension->id());
 }
@@ skipping 51 matching lines @@
 bool InputImeActivateFunction::disable_bubble_for_testing_ = false;
 
 ExtensionFunction::ResponseAction InputImeActivateFunction::Run() {
   if (!IsInputImeEnabled())
     return RespondNow(Error(kErrorAPIDisabled));
   Profile* profile = Profile::FromBrowserContext(browser_context());
   InputImeEventRouter* event_router = GetInputImeEventRouter(profile);
   if (!event_router)
     return RespondNow(Error(kErrorNoActiveEngine));
 
-  // This API is only allowed to be called from a user action.
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
+  bool allowed_to_activate = false;

[Shu Chen, 2016/04/01 08:10:52]

s/allowed_to_activate/warning_bubble_never_show/g

[Azure Wei, 2016/04/01 13:34:04]

Done.

+  bool ime_activated_called = false;
+
+  if (prefs->ReadPrefAsBoolean(extension_id(), kPrefImeActivatedCalledBefore,

[Shu Chen, 2016/04/01 08:10:52]

I think this block should also be after the disable_bubble_for_testing_ check?

[Azure Wei, 2016/04/01 13:34:04]

If put this after disable_bubble_for_testing_, it won't change anything as it
still needs to check user_gesture() every time.
p.s., tests use ScopedUserGestureForTests to make user_gesture() return true.

+                               &ime_activated_called) &&
+      prefs->ReadPrefAsBoolean(extension_id(), kPrefWarningBubbleNeverShow,
+                               &allowed_to_activate) &&
+      !ime_activated_called &&
+      allowed_to_activate) {
+    // If it the first time that the extension call input.ime.activate() since
+    // loaded, we allow it to be automatically activated from a non user action.
+    event_router->SetActiveEngine(extension_id());
+    ExtensionPrefs::Get(profile)->UpdateExtensionPref(
+        extension_id(), kPrefImeActivatedCalledBefore,
+        new base::FundamentalValue(true));
+    return RespondNow(NoArguments());
+  }
+
+  ExtensionPrefs::Get(profile)->UpdateExtensionPref(
+      extension_id(), kPrefImeActivatedCalledBefore,
+      new base::FundamentalValue(true));
+
+  // If not the first time, this API is only allowed to be called from a user
+  // action.
   if (!user_gesture())
     return RespondNow(Error(kErrorNotCalledFromUserAction));
 
   // Disable using the warning bubble for testing.
   if (disable_bubble_for_testing_) {
     GetInputImeEventRouter(profile)->SetActiveEngine(extension_id());
     return RespondNow(NoArguments());
   }
 
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
-  bool allowed_to_activate = false;
-  if (prefs->ReadPrefAsBoolean(extension_id(), kPrefWarningBubbleNeverShow,
-                               &allowed_to_activate) &&
-      allowed_to_activate) {
+  if (allowed_to_activate) {
     // If user allows to activate the extension without showing the warning
     // bubble, sets the active engine directly.
     // Otherwise, the extension will be activated when the user presses the 'OK'
     // button on the warning bubble.
     event_router->SetActiveEngine(extension_id());
     return RespondNow(NoArguments());
   }
 
   Browser* browser = chrome::FindLastActiveWithProfile(profile);
   if (!browser)
@@ skipping 116 matching lines @@
     return RespondNow(Error(kErrorNoActiveEngine));
 
   scoped_ptr<api::input_ime::HideWindow::Params> params(
       api::input_ime::HideWindow::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   engine->HideImeWindow(params->window_id);
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions