[sync] Clean up path generation for the local sync database.

chrome/browser/sync/profile_sync_service_factory.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/profile_sync_service_factory.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/gcm/gcm_profile_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
@@ skipping 47 matching lines @@
 
 void UpdateNetworkTime(const base::Time& network_time,
                        const base::TimeDelta& resolution,
                        const base::TimeDelta& latency) {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&UpdateNetworkTimeOnUIThread, network_time, resolution,
                  latency, base::TimeTicks::Now()));
 }
 
-#if defined(OS_WIN)
-static const base::FilePath::CharType kLoopbackServerBackendFilename[] =
-    FILE_PATH_LITERAL("profile.pb");
-#endif
-
 }  // anonymous namespace
 
 // static
 ProfileSyncServiceFactory* ProfileSyncServiceFactory::GetInstance() {
   return base::Singleton<ProfileSyncServiceFactory>::get();
 }
 
 // static
 ProfileSyncService* ProfileSyncServiceFactory::GetForProfile(
     Profile* profile) {
@@ skipping 60 matching lines @@
   init_params.url_request_context = profile->GetRequestContext();
   init_params.debug_identifier = profile->GetDebugName();
   init_params.channel = chrome::GetChannel();
   base::SequencedWorkerPool* blocking_pool =
       content::BrowserThread::GetBlockingPool();
   init_params.blocking_task_runner =
       blocking_pool->GetSequencedTaskRunnerWithShutdownBehavior(
           blocking_pool->GetSequenceToken(),
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
+  if (!client_factory_) {
+    init_params.sync_client =
+        base::MakeUnique<browser_sync::ChromeSyncClient>(profile);
+  } else {
+    init_params.sync_client = client_factory_->Run(profile);
+  }
+
   bool local_sync_backend_enabled = false;
-
 // Since the local sync backend is currently only supported on Windows don't
 // even check the pref on other os-es.
 #if defined(OS_WIN)
   syncer::SyncPrefs prefs(profile->GetPrefs());
   local_sync_backend_enabled = prefs.IsLocalSyncEnabled();
+  UMA_HISTOGRAM_BOOLEAN("Sync.Local.Enabled", local_sync_backend_enabled);
+
   if (local_sync_backend_enabled) {
-    // This code as it is now will assume the same profile order is present on
-    // all machines, which is not a given. It is to be defined if only the
-    // Default profile should get this treatment or all profile as is the case
-    // now. The solution for now will be to assume profiles are created in the
-    // same order on all machines and in the future decide if only the Default
-    // one should be considered roamed.
-    init_params.local_sync_backend_folder = prefs.GetLocalSyncBackendDir();
-    init_params.local_sync_backend_folder =
-        init_params.local_sync_backend_folder.Append(
-            init_params.base_directory.BaseName());
-    init_params.local_sync_backend_folder =
-        init_params.local_sync_backend_folder.Append(
-            kLoopbackServerBackendFilename);
+    base::FilePath local_sync_backend_folder =
+        init_params.sync_client->GetLocalSyncBackendFolder();
+
+    // If the user has not specified a folder and we can't get the default
+    // roaming profile location the sync service will not be created.
+    UMA_HISTOGRAM_BOOLEAN("Sync.Local.RoamingProfileUnavailable",
+                          local_sync_backend_folder.empty());
+    if (local_sync_backend_folder.empty())
+      return nullptr;
 
     init_params.start_behavior = ProfileSyncService::AUTO_START;
   }
 #endif  // defined(OS_WIN)
 
   if (!local_sync_backend_enabled) {
     SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
 
     // Always create the GCMProfileService instance such that we can listen to
     // the profile notifications and purge the GCM store when the profile is
@@ skipping 15 matching lines @@
     // is set up and *not* a browser restart for a manual-start platform (where
     // sync has already been set up, and should be able to start without user
     // intervention). We can get rid of the browser_default eventually, but
     // need to take care that ProfileSyncService doesn't get tripped up between
     // those two cases. Bug 88109.
     init_params.start_behavior = browser_defaults::kSyncAutoStarts
                                      ? ProfileSyncService::AUTO_START
                                      : ProfileSyncService::MANUAL_START;
   }
 
-  if (!client_factory_) {
-    init_params.sync_client =
-        base::MakeUnique<browser_sync::ChromeSyncClient>(profile);
-  } else {
-    init_params.sync_client = client_factory_->Run(profile);
-  }
-
   auto pss = base::MakeUnique<ProfileSyncService>(std::move(init_params));
 
   // Will also initialize the sync client.
   pss->Initialize();
   return pss.release();
 }
 
 // static
 bool ProfileSyncServiceFactory::HasProfileSyncService(Profile* profile) {
   return GetInstance()->GetServiceForBrowserContext(profile, false) != nullptr;
 }
 
 // static
 void ProfileSyncServiceFactory::SetSyncClientFactoryForTest(
     SyncClientFactory* client_factory) {
   client_factory_ = client_factory;
 }
 
 // static
 ProfileSyncServiceFactory::SyncClientFactory*
     ProfileSyncServiceFactory::client_factory_ = nullptr;