[Sync] Make syncer commands avoid posting tasks on threads with no work to do

chrome/browser/sync/syncable/syncable_unittest.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 "chrome/browser/sync/syncable/syncable.h"
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 29 matching lines @@
 class SyncableKernelTest : public testing::Test {};
 
 // TODO(akalin): Add unit tests for EntryKernel::ContainsString().
 
 TEST_F(SyncableKernelTest, ToValue) {
   EntryKernel kernel;
   scoped_ptr<DictionaryValue> value(kernel.ToValue());
   if (value.get()) {
     // Not much to check without repeating the ToValue() code.
     EXPECT_TRUE(value->HasKey("isDirty"));
-    // The extra +1 is for "isDirty".
-    EXPECT_EQ(BIT_TEMPS_END - BEGIN_FIELDS + 1,
+    // The extra +2 is for "isDirty" and "serverModelType".
+    EXPECT_EQ(BIT_TEMPS_END - BEGIN_FIELDS + 2,
               static_cast<int>(value->size()));
   } else {
     ADD_FAILURE();
   }
 }
 
 namespace {
 void PutDataAsBookmarkFavicon(WriteTransaction* wtrans,
                               MutableEntry* e,
                               const char* bytes,
@@ skipping 301 matching lines @@
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, &dir);
     MutableEntry me(&wtrans, CREATE, wtrans.root_id(), "new");
     ASSERT_TRUE(me.good());
     me.Put(ID, id);
     me.Put(BASE_VERSION, 1);
 
     scoped_ptr<DictionaryValue> value(me.ToValue());
     ExpectDictBooleanValue(true, *value, "good");
     EXPECT_TRUE(value->HasKey("kernel"));
-    ExpectDictStringValue("Unspecified", *value, "serverModelType");
     ExpectDictStringValue("Unspecified", *value, "modelType");
     ExpectDictBooleanValue(true, *value, "existsOnClientBecauseNameIsNonEmpty");
     ExpectDictBooleanValue(false, *value, "isRoot");
   }
 
   dir.SaveChanges();
 }
 
 // A Directory whose backing store always fails SaveChanges by returning false.
 class TestUnsaveableDirectory : public Directory {
@@ skipping 489 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     dir_->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_TRUE(1 == handles.size());
     ASSERT_TRUE(handle2 == handles[0]);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestGetUnappliedUpdates) {
   Directory::UnappliedUpdateMetaHandles handles;
   int64 handle1, handle2;
+  syncable::ModelTypeBitSet all_types;
+  all_types.set();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    dir_->GetUnappliedUpdateMetaHandles(&trans, &handles);
+    dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(0 == handles.size());
 
     MutableEntry e1(&trans, CREATE, trans.root_id(), "abba");
     ASSERT_TRUE(e1.good());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(IS_UNAPPLIED_UPDATE, false);
     e1.Put(BASE_VERSION, 1);
     e1.Put(ID, TestIdFactory::FromNumber(101));
     e1.Put(IS_DIR, true);
 
     MutableEntry e2(&trans, CREATE, e1.Get(ID), "bread");
     ASSERT_TRUE(e2.good());
     handle2 = e2.Get(META_HANDLE);
     e2.Put(IS_UNAPPLIED_UPDATE, false);
     e2.Put(BASE_VERSION, 1);
     e2.Put(ID, TestIdFactory::FromNumber(102));
   }
   dir_->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
-    dir_->GetUnappliedUpdateMetaHandles(&trans, &handles);
+    dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(0 == handles.size());
 
     MutableEntry e3(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(e3.good());
     e3.Put(IS_UNAPPLIED_UPDATE, true);
   }
   dir_->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-    dir_->GetUnappliedUpdateMetaHandles(&trans, &handles);
+    dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(1 == handles.size());
     ASSERT_TRUE(handle1 == handles[0]);
 
     MutableEntry e4(&trans, GET_BY_HANDLE, handle2);
     ASSERT_TRUE(e4.good());
     e4.Put(IS_UNAPPLIED_UPDATE, true);
   }
   dir_->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-    dir_->GetUnappliedUpdateMetaHandles(&trans, &handles);
+    dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(2 == handles.size());
     if (handle1 == handles[0]) {
       ASSERT_TRUE(handle2 == handles[1]);
     } else {
       ASSERT_TRUE(handle2 == handles[0]);
       ASSERT_TRUE(handle1 == handles[1]);
     }
 
     MutableEntry e5(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(e5.good());
     e5.Put(IS_UNAPPLIED_UPDATE, false);
   }
   dir_->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
-    dir_->GetUnappliedUpdateMetaHandles(&trans, &handles);
+    dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(1 == handles.size());
     ASSERT_TRUE(handle2 == handles[0]);
   }
 }
 
 
 TEST_F(SyncableDirectoryTest, DeleteBug_531383) {
   // Try to evoke a check failure...
   TestIdFactory id_factory;
   int64 grandchild_handle;
@@ skipping 935 matching lines @@
 TEST_F(SyncableClientTagTest, TestClientTagIndexDuplicateServer) {
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable