sync: Better iteration in GenericChangeProcessor

chrome/browser/sync/glue/generic_change_processor_unittest.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 "chrome/browser/sync/glue/generic_change_processor.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop.h"
+#include "base/stringprintf.h"
+#include "chrome/browser/sync/glue/data_type_error_handler_mock.h"
+#include "sync/api/fake_syncable_service.h"
+#include "sync/api/sync_merge_result.h"
+#include "sync/internal_api/public/base/model_type.h"
+#include "sync/internal_api/public/read_node.h"
+#include "sync/internal_api/public/test/test_user_share.h"
+#include "sync/internal_api/public/user_share.h"
+#include "sync/internal_api/public/write_node.h"
+#include "sync/internal_api/public/write_transaction.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace browser_sync {
+
+namespace {
+
+class GenericChangeProcessorTest : public testing::Test {
+ public:
+  // It doesn't matter which type we use.  Just pick one.
+  static const syncer::ModelType kType = syncer::PREFERENCES;
+
+  GenericChangeProcessorTest() :
+      loop(base::MessageLoop::TYPE_UI),
+      sync_merge_result_(kType),
+      merge_result_ptr_factory_(&sync_merge_result_),
+      syncable_service_ptr_factory_(&fake_syncable_service_) {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    test_user_share_.SetUp();
+    syncer::TestUserShare::CreateRoot(kType, test_user_share_.user_share());
+    change_processor_.reset(
+        new GenericChangeProcessor(
+            &data_type_error_handler_,
+            syncable_service_ptr_factory_.GetWeakPtr(),
+            merge_result_ptr_factory_.GetWeakPtr(),
+            test_user_share_.user_share()));
+  }
+
+  virtual void TearDown() OVERRIDE {
+    test_user_share_.TearDown();
+  }
+
+  void BuildChildNodes(int n) {
+    syncer::WriteTransaction trans(FROM_HERE, user_share());
+    syncer::ReadNode root(&trans);
+    ASSERT_EQ(syncer::BaseNode::INIT_OK,
+              root.InitByTagLookup(syncer::ModelTypeToRootTag(kType)));
+    for (int i = 0; i < n; ++i) {
+      syncer::WriteNode node(&trans);
+      node.InitUniqueByCreation(kType, root, base::StringPrintf("node%05d", i));
+    }
+  }
+
+  GenericChangeProcessor* change_processor() {
+    return change_processor_.get();
+  }
+
+  syncer::UserShare* user_share() {
+    return test_user_share_.user_share();
+  }
+
+ private:
+  MessageLoop loop;
+
+  syncer::SyncMergeResult sync_merge_result_;
+  base::WeakPtrFactory<syncer::SyncMergeResult> merge_result_ptr_factory_;
+
+  syncer::FakeSyncableService fake_syncable_service_;
+  base::WeakPtrFactory<syncer::FakeSyncableService>
+      syncable_service_ptr_factory_;
+
+  DataTypeErrorHandlerMock data_type_error_handler_;
+  syncer::TestUserShare test_user_share_;
+
+  scoped_ptr<GenericChangeProcessor> change_processor_;
+};
+
+// This test exercises GenericChangeProcessor's GetSyncDataForType function.
+// It's not a great test, but, by modifying some of the parameters, you could
+// turn it into a micro-benchmark for model association.
+TEST_F(GenericChangeProcessorTest, StressGetSyncDataForType) {
+  const int kNumChildNodes = 1000;
+  const int kRepeatCount = 1;
+
+  ASSERT_NO_FATAL_FAILURE(BuildChildNodes(kNumChildNodes));
+
+  for (int i = 0; i < kRepeatCount; ++i) {
+    syncer::SyncDataList sync_data;
+    change_processor()->GetSyncDataForType(kType, &sync_data);
+
+    // Start with a simple test.  We can add more in-depth testing later.
+    EXPECT_EQ(static_cast<size_t>(kNumChildNodes), sync_data.size());
+  }
+}
+
+}  // namespace
+
+}  // namespace browser_sync
+