Build sync engine as part of the browser build

chrome/browser/sync/syncable/syncable_unittest.cc

 // Copyright (c) 2009 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 "build/build_config.h"
+
 #include <sys/types.h>
 
 #include <iostream>
 #include <limits>
 #include <string>
 
 // TODO(ncarter): Winnow down the OS-specific includes from the test
 // file.
-#if defined(OS_WINDOWS)
+#if defined(OS_WIN)
 #include <tchar.h>
 #include <atlbase.h>
 #include <process.h>
-#endif  // defined(OS_WINDOWS)
+#endif  // defined(OS_WIN)
 
-#if !defined(OS_WINDOWS)
+#if !defined(OS_WIN)
 #define MAX_PATH PATH_MAX
 #include <strstream>
 #include <ostream>
 #include <stdio.h>
 #include <sys/ipc.h>
 #include <sys/sem.h>
 #include <sys/times.h>
-#endif  // !defined(OS_WINDOWS)
+#endif  // !defined(OS_WIN)
 
 #include "base/at_exit.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/util/character_set_converters.h"
 #include "chrome/browser/sync/util/closure.h"
-#include "chrome/browser/sync/util/compat-file.h"
+#include "chrome/browser/sync/util/compat_file.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 #include "chrome/browser/sync/util/pthread_helpers.h"
 #include "chrome/browser/sync/util/query_helpers.h"
 #include "chrome/test/sync/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/preprocessed/sqlite3.h"
 
 using browser_sync::TestIdFactory;
 using std::cout;
@@ skipping 925 matching lines @@
 
 timespec operator + (const timespec& a, const timespec& b) {
   const long nanos = a.tv_nsec + b.tv_nsec;
   static const long nanos_per_second = 1000000000;
   timespec r = { a.tv_sec + b.tv_sec + (nanos / nanos_per_second),
                  nanos % nanos_per_second };
   return r;
 }
 
 void SleepMs(int milliseconds) {
-#ifdef OS_WINDOWS
+#ifdef OS_WIN
   Sleep(milliseconds);
 #else
   usleep(milliseconds * 1000);
 #endif
 }
 
 namespace StressTransaction {
   struct Globals {
     DirectoryManager* dirman;
     PathString dirname;
@@ skipping 132 matching lines @@
     PathString a(1, tests[i].a);
     PathString b(1, tests[i].b);
     const int result = ComparePathNames(a, b);
     if (result != tests[i].expected_result) {
       ADD_FAILURE() << "ComparePathNames(" << tests[i].a << ", " << tests[i].b
        << ") returned " << result << "; expected "
        << tests[i].expected_result;
     }
   }
 
-#ifndef OS_WINDOWS
+#ifndef OS_WIN
   // This table lists (to the best of my knowledge) every pair of characters
   // in unicode such that:
   // for all i: tolower(kUpperToLowerMap[i].upper) = kUpperToLowerMap[i].lower
   // This is then used to test that case-insensitive comparison of each pair
   // returns 0 (that, that they are equal). After running the test on Mac OS X
   // with the CFString API for comparision, the failing cases were commented
   // out.
   //
   // Map of upper to lower case characters taken from
   // ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
@@ skipping 319 matching lines @@
     if (0 != result) {
       // This ugly strstream works around an issue where using << hex on the
       // stream for ADD_FAILURE produces "true" and "false" in the output.
       strstream msg;
       msg << "ComparePathNames(0x" << hex << kUpperToLowerMap[i].upper
         << ", 0x" << hex << kUpperToLowerMap[i].lower
         << ") returned " << dec << result << "; expected 0" << '\0';
       ADD_FAILURE() << msg.str();
     }
   }
-#endif  // not defined OS_WINDOWS
+#endif  // not defined OS_WIN
 }
 
-#ifdef OS_WINDOWS
+#ifdef OS_WIN
 TEST(Syncable, PathNameMatch) {
   // basic stuff, not too many otherwise we're testing the os.
   EXPECT_TRUE(PathNameMatch(PSTR("bob"), PSTR("bob")));
   EXPECT_FALSE(PathNameMatch(PSTR("bob"), PSTR("fred")));
   // Test our ; extension.
   EXPECT_TRUE(PathNameMatch(PSTR("bo;b"), PSTR("bo;b")));
   EXPECT_TRUE(PathNameMatch(PSTR("bo;b"), PSTR("bo*")));
   EXPECT_FALSE(PathNameMatch(PSTR("bo;b"), PSTR("co;b")));
   EXPECT_FALSE(PathNameMatch(PSTR("bo;b"), PSTR("co*")));
   // Test our fixes for prepended spaces.
   EXPECT_TRUE(PathNameMatch(PSTR("  bob"), PSTR("  bo*")));
   EXPECT_TRUE(PathNameMatch(PSTR("  bob"), PSTR("  bob")));
   EXPECT_FALSE(PathNameMatch(PSTR("bob"), PSTR("  bob")));
   EXPECT_FALSE(PathNameMatch(PSTR("  bob"), PSTR("bob")));
   // Combo test.
   EXPECT_TRUE(PathNameMatch(PSTR("  b;ob"), PSTR("  b;o*")));
   EXPECT_TRUE(PathNameMatch(PSTR("  b;ob"), PSTR("  b;ob")));
   EXPECT_FALSE(PathNameMatch(PSTR("b;ob"), PSTR("  b;ob")));
   EXPECT_FALSE(PathNameMatch(PSTR("  b;ob"), PSTR("b;ob")));
   // other whitespace should give no matches.
   EXPECT_FALSE(PathNameMatch(PSTR("bob"), PSTR("\tbob")));
 }
-#endif  // OS_WINDOWS
+#endif  // OS_WIN
 
 }  // namespace
 
 void FakeSync(MutableEntry* e, const char* fake_id) {
   e->Put(IS_UNSYNCED, false);
   e->Put(BASE_VERSION, 2);
   e->Put(ID, Id::CreateFromServerId(fake_id));
 }
 
 TEST_F(SyncableDirectoryTest, Bug1509232) {
@@ skipping 11 matching lines @@
     Blob value_blob(value, value + ARRAYSIZE(value));
     ext.mutable_value()->swap(value_blob);
     ext.delete_attribute();
   }
   // This call to SaveChanges used to CHECK fail.
   dir_.get()->SaveChanges();
 }
 
 }  // namespace syncable
 
-#ifdef OS_WINDOWS
+#ifdef OS_WIN
 class LocalModule : public CAtlExeModuleT<LocalModule> { };
 LocalModule module_;
 
 int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
 
   // TODO(chron) Add method to change random seed.
   const int32 test_random_seed = time(NULL);
   cout << "Random seed: " << test_random_seed << endl;
   LOG(INFO) << "Random seed: " << test_random_seed << endl;
   srand(test_random_seed);
 
   // Necessary for NewCallback, scoped to main
   base::AtExitManager at_exit_manager;
 
   int result = RUN_ALL_TESTS();
   return result;
 }
 #endif