[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 {

[akalin, 2012/03/21 01:23:19]

hmm...it seems like we either need to avoid creating the delegate (like in my
app notification comments) or decomp this into its own file or something

[Nicolas Zea, 2012/03/21 17:38:27]

Yeah, I plan to pull this and some form of the NoopSyncChangeProcessor above
into their own classes as part of a follow-up CL.

+ public:
+  explicit SyncChangeProcessorDelegate(SyncChangeProcessor* recipient)
+      : recipient_(recipient) {
+    DCHECK(recipient_);
+  }
+
+  // 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