Build sync engine as part of the browser build

chrome/browser/sync/engine/syncapi.cc

 // Copyright (c) 2006-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/engine/syncapi.h"
 
-#if defined(OS_WINDOWS)
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
 #include <windows.h>
 #include <iphlpapi.h>
 #endif
 
 #include <iomanip>
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 52 matching lines @@
 // of multiple threads, and if some other part also tries to call InitLogFiles
 // apart from this file. But this is okay for now since this is the only place
 // we call InitLogFiles.
 namespace {
 static bool g_log_files_initialized = false;
 static base::AtExitManager g_at_exit_manager;  // Necessary for NewCallback.
 }  // namespace
 
 struct ThreadParams {
   browser_sync::ServerConnectionManager* conn_mgr;
-#if defined(OS_WINDOWS)
+#if defined(OS_WIN)
   HANDLE exit_flag;
 #endif
 };
 
 // This thread calls CheckServerReachable() whenever a change occurs in the
 // table that maps IP addresses to interfaces, for example when the user
 // unplugs his network cable.
 void* AddressWatchThread(void* arg) {
   NameCurrentThreadForDebugging("SyncEngine_AddressWatcher");
   LOG(INFO) << "starting the address watch thread";
   const ThreadParams* const params = reinterpret_cast<const ThreadParams*>(arg);
-#if defined(OS_WINDOWS)
+#if defined(OS_WIN)
   OVERLAPPED overlapped = {0};
   overlapped.hEvent = CreateEvent(NULL, FALSE, TRUE, NULL);
   HANDLE file;
   DWORD rc = WAIT_OBJECT_0;
   while (true) {
     // Only call NotifyAddrChange() after the IP address has changed or if this
     // is the first time through the loop.
     if (WAIT_OBJECT_0 == rc) {
       ResetEvent(overlapped.hEvent);
       DWORD notify_result = NotifyAddrChange(&file, &overlapped);
@@ skipping 58 matching lines @@
   return false;
 }
 
 static bool EndsWithSpace(const string16& string) {
   return !string.empty() && *string.rbegin() == ' ';
 }
 
 static inline void String16ToPathString(const sync_char16 *in,
                                         PathString *out) {
   string16 in_str(in);
-#if defined(OS_WINDOWS)
+#if defined(OS_WIN)
   out->assign(in_str);
 #else
   UTF16ToUTF8(in_str.c_str(), in_str.length(), out);
 #endif
 }
 
 static inline void PathStringToString16(const PathString& in, string16* out) {
-#if defined(OS_WINDOWS)
+#if defined(OS_WIN)
   out->assign(in);
 #else
   UTF8ToUTF16(in.c_str(), in.length(), out);
 #endif
 }
 
 // When taking a name from the syncapi, append a space if it matches the
 // pattern of a server-illegal name followed by zero or more spaces.
 static void SyncAPINameToServerName(const sync_char16 *sync_api_name,
                                     PathString* out) {
@@ skipping 816 matching lines @@
   string client_id = user_settings_->GetClientId();
   connection_manager_.reset(new SyncAPIServerConnectionManager(
       sync_server_and_path, port, use_ssl, user_agent, client_id));
 
   // TODO(timsteele): This is temporary windows crap needed to listen for
   // network status changes. We should either pump this up to the embedder to
   // do (and call us in CheckServerReachable, for ex), or at least make this
   // platform independent in here.
   // TODO(ncarter): When this gets cleaned up, the implementation of
   // CreatePThread can also be removed.
-#if defined(OS_WINDOWS)
+#if defined(OS_WIN)
   HANDLE exit_flag = CreateEvent(NULL, TRUE /*manual reset*/, FALSE, NULL);
   address_watch_params_.exit_flag = exit_flag;
 #endif
   address_watch_params_.conn_mgr = connection_manager();
   address_watch_thread_ = CreatePThread(AddressWatchThread,
                                         &address_watch_params_);
   DCHECK(NULL != address_watch_thread_);
 
   // Hand over the bridged POST factory to be owned by the connection
   // dir_manager.
@@ skipping 173 matching lines @@
   // Reset the DirectoryManager and UserSettings so they relinquish sqlite
   // handles to backing files.
   share_.dir_manager.reset();
   user_settings_.reset();
 
   // We don't want to process any more events.
   dir_change_hookup_.reset();
   syncer_event_.reset();
   authwatcher_hookup_.reset();
 
-#if defined(OS_WINDOWS)
+#if defined(OS_WIN)
   // Stop the address watch thread by signaling the exit flag.
   // TODO(timsteele): Same as todo in Init().
   SetEvent(address_watch_params_.exit_flag);
   const DWORD wait_result = WaitForSingleObject(address_watch_thread_,
                                                 kThreadExitTimeoutMsec);
   LOG_IF(ERROR, WAIT_FAILED == wait_result) << "Waiting for addr change thread "
       "to exit failed. GetLastError(): " << hex << GetLastError();
   LOG_IF(ERROR, WAIT_TIMEOUT == wait_result) << "Thread exit timeout expired";
   CloseHandle(address_watch_params_.exit_flag);
 #endif
@@ skipping 335 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api