Add onChanged events to the extension settings API, both from sync and between

chrome/browser/extensions/extension_settings_apitest.cc

 // 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.
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_settings_backend.h"
+#include "chrome/browser/extensions/extension_settings_sync_util.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sync/api/sync_change.h"
+#include "chrome/browser/sync/api/sync_change_processor.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 
+namespace {
+
+class NoopSyncChangeProcessor : public SyncChangeProcessor {
+ public:
+  virtual SyncError ProcessSyncChanges(
+      const tracked_objects::Location& from_here,
+      const SyncChangeList& change_list) OVERRIDE {
+    return SyncError();
+  }
+
+  virtual ~NoopSyncChangeProcessor() {};
+};
+
+}  // namespace
+
 class ExtensionSettingsApiTest : public ExtensionApiTest {
  protected:
   void ReplyWhenSatisfied(
       const std::string& normal_action,
       const std::string& incognito_action) {
     MaybeLoadAndReplyWhenSatisfied(
         normal_action, incognito_action, NULL, false);
   }
 
-  void LoadAndReplyWhenSatisfied(
+  const Extension* LoadAndReplyWhenSatisfied(
       const std::string& normal_action,
       const std::string& incognito_action,
       const std::string& extension_dir) {
-    MaybeLoadAndReplyWhenSatisfied(
+    return MaybeLoadAndReplyWhenSatisfied(
         normal_action, incognito_action, &extension_dir, false);
   }
 
   void FinalReplyWhenSatisfied(
       const std::string& normal_action,
       const std::string& incognito_action) {
     MaybeLoadAndReplyWhenSatisfied(normal_action, incognito_action, NULL, true);
   }
 
+  void InitSync(SyncChangeProcessor* sync_processor) {
+    browser()->profile()->GetExtensionService()->
+        extension_settings_frontend()->RunWithBackend(base::Bind(
+            &ExtensionSettingsApiTest::InitSyncWithBackend,
+            this,
+            sync_processor));
+  }
+
+  void SendChanges(const SyncChangeList& change_list) {
+    browser()->profile()->GetExtensionService()->
+        extension_settings_frontend()->RunWithBackend(base::Bind(
+            &ExtensionSettingsApiTest::SendChangesToBackend,
+            this,
+            change_list));
+  }
+
  private:
-  void MaybeLoadAndReplyWhenSatisfied(
+  const Extension* MaybeLoadAndReplyWhenSatisfied(
       const std::string& normal_action,
       const std::string& incognito_action,
       // May be NULL to imply not loading the extension.
       const std::string* extension_dir,
       bool is_final_action) {
     ExtensionTestMessageListener listener("waiting", true);
     ExtensionTestMessageListener listener_incognito("waiting_incognito", true);
 
     // Only load the extension after the listeners have been set up, to avoid
     // initialisation race conditions.
+    const Extension* extension = NULL;
     if (extension_dir) {
-      ASSERT_TRUE(LoadExtensionIncognito(test_data_dir_
-          .AppendASCII("settings").AppendASCII(*extension_dir)));
+      extension = LoadExtensionIncognito(
+          test_data_dir_.AppendASCII("settings").AppendASCII(*extension_dir));
+      EXPECT_TRUE(extension);
     }
 
     EXPECT_TRUE(listener.WaitUntilSatisfied());
     EXPECT_TRUE(listener_incognito.WaitUntilSatisfied());
 
     listener.Reply(CreateMessage(normal_action, is_final_action));
     listener_incognito.Reply(CreateMessage(incognito_action, is_final_action));
+    return extension;
   }
 
   std::string CreateMessage(const std::string& action, bool is_final_action) {
     scoped_ptr<DictionaryValue> message(new DictionaryValue());
     message->SetString("action", action);
     message->SetBoolean("isFinalAction", is_final_action);
     std::string message_json;
     base::JSONWriter::Write(message.get(), false, &message_json);
     return message_json;
   }
+
+  void InitSyncWithBackend(
+      SyncChangeProcessor* sync_processor, ExtensionSettingsBackend* backend) {
+    EXPECT_FALSE(backend->MergeDataAndStartSyncing(
+        syncable::EXTENSION_SETTINGS,
+        SyncDataList(),
+        sync_processor).IsSet());
+  }
+
+  void SendChangesToBackend(
+      const SyncChangeList& change_list, ExtensionSettingsBackend* backend) {
+    EXPECT_FALSE(backend->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
+  }
 };
 
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, SimpleTest) {
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableExperimentalExtensionApis);
   ASSERT_TRUE(RunExtensionTest("settings/simple_test")) << message_;
 }
 
 // Structure of this test taken from DISABLED_IncognitoSplitMode, so it's
 // likely that they will need to be disabled on the bots, too.  See
 // http://crbug.com/53991.
 //
 // Note that only split-mode incognito is tested, because spanning mode
 // incognito looks the same as normal mode when the only API activity comes
 // from background pages.
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, SplitModeIncognito) {
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableExperimentalExtensionApis);
 
   // We need 2 ResultCatchers because we'll be running the same test in both
   // regular and incognito mode.
   ResultCatcher catcher, catcher_incognito;
   catcher.RestrictToProfile(browser()->profile());
   catcher_incognito.RestrictToProfile(
       browser()->profile()->GetOffTheRecordProfile());
 
   LoadAndReplyWhenSatisfied("assertEmpty", "assertEmpty", "split_incognito");
-  ReplyWhenSatisfied("noop", "setFoobar");
-  ReplyWhenSatisfied("assertFoobar", "assertFoobar");
+  ReplyWhenSatisfied("noop", "setFoo");
+  ReplyWhenSatisfied("assertFoo", "assertFoo");
   ReplyWhenSatisfied("clear", "noop");
   ReplyWhenSatisfied("assertEmpty", "assertEmpty");
-  ReplyWhenSatisfied("setFoobar", "noop");
-  ReplyWhenSatisfied("assertFoobar", "assertFoobar");
+  ReplyWhenSatisfied("setFoo", "noop");
+  ReplyWhenSatisfied("assertFoo", "assertFoo");
   ReplyWhenSatisfied("noop", "removeFoo");
   FinalReplyWhenSatisfied("assertEmpty", "assertEmpty");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 }
+
+IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
+    OnChangedNotificationsBetweenBackgroundPages) {
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kEnableExperimentalExtensionApis);
+
+  // We need 2 ResultCatchers because we'll be running the same test in both
+  // regular and incognito mode.
+  ResultCatcher catcher, catcher_incognito;
+  catcher.RestrictToProfile(browser()->profile());
+  catcher_incognito.RestrictToProfile(
+      browser()->profile()->GetOffTheRecordProfile());
+
+  LoadAndReplyWhenSatisfied(
+      "assertNoNotifications", "assertNoNotifications", "split_incognito");
+  ReplyWhenSatisfied("noop", "setFoo");
+  ReplyWhenSatisfied("assertAddFooNotification", "assertNoNotifications");

[not at google - send to devlin, 2011/10/11 03:58:48]

Hmmm, assertAddFooNotification here and below fails about 3/4 times on Windows
bots, but always passes on Linux/Mac bots (from a sample of 10 try jobs each). 
How very odd.

Since I suppose it might actually be a legitimate test failure, I'll have to
find a Windows computer to test this on.  Bummer.

[not at google - send to devlin, 2011/10/12 05:43:30]

Not to jinx myself, but I think this is fixed now.  It was just a problem with
tests; making the JS stuff properly asynchronous almost fixed it; adding retry
logic completely fixed it.

There might be something I can do on the C++ side so as to not need the retry
logic.

+  ReplyWhenSatisfied("clearNotifications", "noop");
+  ReplyWhenSatisfied("removeFoo", "noop");
+  FinalReplyWhenSatisfied(
+      "assertNoNotifications", "assertDeleteFooNotification");
+
+  EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
+  EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
+    OnChangedNotificationsFromSync) {
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kEnableExperimentalExtensionApis);
+
+  // We need 2 ResultCatchers because we'll be running the same test in both
+  // regular and incognito mode.
+  ResultCatcher catcher, catcher_incognito;
+  catcher.RestrictToProfile(browser()->profile());
+  catcher_incognito.RestrictToProfile(
+      browser()->profile()->GetOffTheRecordProfile());
+
+  const Extension* extension =
+      LoadAndReplyWhenSatisfied(
+          "assertNoNotifications", "assertNoNotifications", "split_incognito");
+  const std::string& extension_id = extension->id();
+
+  NoopSyncChangeProcessor sync_processor;
+  InitSync(&sync_processor);
+
+  // Set "foo" to "bar" via sync.
+  SyncChangeList sync_changes;
+  StringValue bar("bar");
+  sync_changes.push_back(extension_settings_sync_util::CreateAdd(
+      extension_id, "foo", bar));
+  SendChanges(sync_changes);
+
+  ReplyWhenSatisfied("assertAddFooNotification", "assertAddFooNotification");
+  ReplyWhenSatisfied("clearNotifications", "clearNotifications");
+
+  // Remove "foo" via sync.
+  sync_changes.clear();
+  sync_changes.push_back(extension_settings_sync_util::CreateDelete(
+      extension_id, "foo"));
+  SendChanges(sync_changes);
+
+  FinalReplyWhenSatisfied(
+      "assertDeleteFooNotification", "assertDeleteFooNotification");
+
+  EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
+  EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
+}