Adds extension events for custom dictionary load/change.

chrome/test/data/extensions/api_test/input_method/background.js

 // Copyright (c) 2011 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.
 
 var kNewInputMethodTemplate = '_comp_ime_{EXT_ID}xkb:fr::fra';
 var kInitialInputMethodRegex = /_comp_ime_([a-z]{32})xkb:us::eng/;
 var kInvalidInputMethod = 'xx::xxx';
 
 var testParams = {
   initialInputMethod: '',
-  newInputMethod: ''
+  newInputMethod: '',
+  dictionaryLoaded: null,
 };
 
 // The tests needs to be executed in order.
 
 function initTests() {
   console.log('initTest: Getting initial inputMethod');
   chrome.inputMethodPrivate.getCurrentInputMethod(function(inputMethod) {
     testParams.initialInputMethod = inputMethod;
 
     var match = inputMethod.match(kInitialInputMethodRegex);
@@ skipping 70 matching lines @@
         foundInitialInputMethod = true;
       if (inputMethods[i].id == testParams.newInputMethod)
         foundNewInputMethod = true;
     }
     chrome.test.assertTrue(foundInitialInputMethod);
     chrome.test.assertTrue(foundNewInputMethod);
     chrome.test.succeed();
   });
 }
 
-function initDictionaryNotLoadedTest() {
-  // This test must come first because the dictionary is only lazy loaded after
-  // this call is made.
-  chrome.inputMethodPrivate.fetchAllDictionaryWords(function(words) {
-    chrome.test.assertTrue(words === undefined);
-    chrome.test.assertTrue(!!chrome.runtime.lastError);
-    chrome.test.succeed();
+// Helper function
+function getFetchPromise() {
+  return new Promise(function(resolve, reject) {
+    chrome.inputMethodPrivate.fetchAllDictionaryWords(function(words) {
+      if (!!chrome.runtime.lastError) {
+        reject(Error(chrome.runtime.lastError));
+      } else {
+        resolve(words);
+      }
+    });
   });
 }
 
-function initDictionaryTests() {
-  chrome.inputMethodPrivate.fetchAllDictionaryWords(function(words) {
-    chrome.test.assertTrue(words !== undefined);
-    chrome.test.assertTrue(words.length === 0);
-    chrome.test.succeed();
+// Helper function
+function getAddPromise(word) {
+  return new Promise(function(resolve, reject) {
+    chrome.inputMethodPrivate.addWordToDictionary(word, function() {
+      if (!!chrome.runtime.lastError) {
+        reject(Error(chrome.runtime.lastError));
+      } else {
+        resolve();
+      }
+    });
   });
 }
 
+function loadDictionaryAsyncTest() {
+  testParams.dictionaryLoaded = new Promise(function(resolve, reject) {
+    var message = 'before';
+    chrome.inputMethodPrivate.onDictionaryLoaded.addListener(
+        function listener() {
+          chrome.inputMethodPrivate.onDictionaryLoaded.removeListener(listener);
+          chrome.test.assertEq(message, 'after');
+          resolve();
+        });
+    message = 'after';
+  });
+  // We don't need to wait for the promise to resolve before continuing since
+  // promises are async wrappers.
+  chrome.test.succeed();
+}
+
+function fetchDictionaryTest() {
+  testParams.dictionaryLoaded
+      .then(function () {
+        return getFetchPromise();
+      })
+      .then(function confirmFetch(words) {
+        chrome.test.assertTrue(words !== undefined);
+        chrome.test.assertTrue(words.length === 0);
+        chrome.test.succeed();
+      });
+}
+
 function addWordToDictionaryTest() {
-  chrome.inputMethodPrivate.addWordToDictionary('helloworld', function() {
-    chrome.inputMethodPrivate.fetchAllDictionaryWords(function(words) {
-      chrome.test.assertTrue(words.length === 1);
-      chrome.test.assertEq(words[0], 'helloworld');
-      chrome.test.succeed();
-    });
-  });
+  var wordToAdd = 'helloworld';
+  testParams.dictionaryLoaded
+      .then(function() {
+        return getAddPromise(wordToAdd);
+      })
+      // Adding the same word results in an error.
+      .then(function() {
+        return getAddPromise(wordToAdd);
+      })
+      .catch(function(error) {
+        chrome.test.assertTrue(!!error.message);
+        return getFetchPromise();
+      })
+      .then(function(words) {
+        chrome.test.assertTrue(words.length === 1);
+        chrome.test.assertEq(words[0], wordToAdd);
+        chrome.test.succeed();
+      });
+}
+
+function dictionaryChangedTest() {
+  var wordToAdd = 'helloworld2';
+  testParams.dictionaryLoaded
+      .then(function() {
+        chrome.inputMethodPrivate.onDictionaryChanged.addListener(
+            function(added, removed) {
+              chrome.test.assertTrue(added.length === 1);
+              chrome.test.assertTrue(removed.length === 0);
+              chrome.test.assertEq(added[0], wordToAdd);
+              chrome.test.succeed();
+            });
+      })
+      .then(function() {
+        return getAddPromise(wordToAdd);
+      });
 }
 
 chrome.test.sendMessage('ready');
 chrome.test.runTests(
     [initTests, setTest, getTest, observeTest, setInvalidTest, getListTest,
-     initDictionaryNotLoadedTest, initDictionaryTests,
-     addWordToDictionaryTest]);
+     loadDictionaryAsyncTest, fetchDictionaryTest, addWordToDictionaryTest,
+     dictionaryChangedTest]);