[Sync] Have SyncableService's take ownership of their SyncChangeProcessor.

chrome/browser/extensions/settings/settings_apitest.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 "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/settings/settings_frontend.h"
@@ skipping 24 matching lines @@
  public:
   virtual SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const SyncChangeList& change_list) OVERRIDE {
     return SyncError();
   }
 
   virtual ~NoopSyncChangeProcessor() {};
 };
 
+class SyncChangeProcessorDelegate : public SyncChangeProcessor {

[asargent_no_longer_on_chrome, 2012/03/22 22:54:11]

This looks like duplicate code from the version in
app_notification_manager_sync_unittest.cc - can we put it in it's own standalone
.h/cc file somewhere so we can share the code?

[Nicolas Zea, 2012/03/22 23:05:29]

That will be arriving as part of a follow-up patch (along with pulling the
various implementations of the above NoopSyncChangeProcessor out into a single
class as well).

[asargent_no_longer_on_chrome, 2012/03/22 23:14:24]

Ok, glad to hear it.

+ public:
+  explicit SyncChangeProcessorDelegate(SyncChangeProcessor* recipient)
+      : recipient_(recipient) {
+    DCHECK(recipient_);
+  }
+  virtual ~SyncChangeProcessorDelegate() {}
+
+  // SyncChangeProcessor implementation.
+  virtual SyncError ProcessSyncChanges(
+      const tracked_objects::Location& from_here,
+      const SyncChangeList& change_list) OVERRIDE {
+    return recipient_->ProcessSyncChanges(from_here, change_list);
+  }
+
+ private:
+  // The recipient of all sync changes.
+  SyncChangeProcessor* recipient_;
+};
+
 }  // namespace
 
 class ExtensionSettingsApiTest : public ExtensionApiTest {
  protected:
   void ReplyWhenSatisfied(
       Namespace settings_namespace,
       const std::string& normal_action,
       const std::string& incognito_action) {
     MaybeLoadAndReplyWhenSatisfied(
         settings_namespace, normal_action, incognito_action, NULL, false);
@@ skipping 77 matching lines @@
     std::string message_json;
     base::JSONWriter::Write(message.get(), &message_json);
     return message_json;
   }
 
   void InitSyncWithSyncableService(
       SyncChangeProcessor* sync_processor, SyncableService* settings_service) {
     EXPECT_FALSE(settings_service->MergeDataAndStartSyncing(
         kModelType,
         SyncDataList(),
-        sync_processor).IsSet());
+        scoped_ptr<SyncChangeProcessor>(
+            new SyncChangeProcessorDelegate(sync_processor))).IsSet());
   }
 
   void SendChangesToSyncableService(
       const SyncChangeList& change_list, SyncableService* settings_service) {
     EXPECT_FALSE(
         settings_service->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
   }
 };
 
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, SimpleTest) {
@@ skipping 196 matching lines @@
   SendChanges(sync_changes);
 
   FinalReplyWhenSatisfied(LOCAL,
       "assertNoNotifications", "assertNoNotifications");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
 }
 
 }  // namespace extensions