WIP: Local sync only...

components/browser_sync/profile_sync_service.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 "components/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 214 matching lines @@
       encrypt_everything_allowed_(true),
       encrypt_everything_(false),
       encryption_pending_(false),
       configure_status_(DataTypeManager::UNKNOWN),
       oauth2_token_service_(init_params.oauth2_token_service),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       connection_status_(syncer::CONNECTION_NOT_ATTEMPTED),
       last_get_token_error_(GoogleServiceAuthError::AuthErrorNone()),
       gaia_cookie_manager_service_(init_params.gaia_cookie_manager_service),
       network_resources_(new syncer::HttpBridgeNetworkResources),
-      start_behavior_(init_params.start_behavior),
+      start_behavior_(AUTO_START /*init_params.start_behavior*/),
       directory_path_(
           base_directory_.Append(base::FilePath(kSyncDataFolderName))),
       catch_up_configure_in_progress_(false),
       passphrase_prompt_triggered_by_version_(false),
       sync_enabled_weak_factory_(this),
       weak_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(sync_client_);
   std::string last_version = sync_prefs_.GetLastRunVersion();
   std::string current_version = PRODUCT_VERSION;
   sync_prefs_.SetLastRunVersion(current_version);
 
   // Check for a major version change. Note that the versions have format
   // MAJOR.MINOR.BUILD.PATCH.
   if (last_version.substr(0, last_version.find('.')) !=
       current_version.substr(0, current_version.find('.'))) {
     passphrase_prompt_triggered_by_version_ = true;
   }
 }
 
 ProfileSyncService::~ProfileSyncService() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
   sync_prefs_.RemoveSyncPrefObserver(this);
   // Shutdown() should have been called before destruction.
   CHECK(!backend_initialized_);
 }
 
 bool ProfileSyncService::CanSyncStart() const {
-  return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
+  // ### Only if needed.
+  return IsSyncAllowed() && IsSyncRequested();// && IsSignedIn();
 }
 
 void ProfileSyncService::Initialize() {
+  LOG(ERROR) << "@@@@ INIT CALLED";
+  //sync_prefs_.SetFirstSetupComplete();
   sync_client_->Initialize();
 
   // We don't pass StartupController an Unretained reference to future-proof
   // against the controller impl changing to post tasks.
   startup_controller_.reset(new browser_sync::StartupController(
       &sync_prefs_,
       base::Bind(&ProfileSyncService::CanBackendStart, base::Unretained(this)),
       base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
                  weak_factory_.GetWeakPtr())));
   std::unique_ptr<sync_sessions::LocalSessionEventRouter> router(
@@ skipping 32 matching lines @@
     device_info_sync_service_.reset(
         new DeviceInfoSyncService(local_device_.get()));
   }
 
   sync_driver::SyncApiComponentFactory::RegisterDataTypesMethod
       register_platform_types_callback =
           sync_client_->GetRegisterPlatformTypesCallback();
   sync_client_->GetSyncApiComponentFactory()->RegisterDataTypes(
       this, register_platform_types_callback);
 
-  if (gaia_cookie_manager_service_)
-    gaia_cookie_manager_service_->AddObserver(this);
+
+  // ### We have to change this to only do it if needed.
+  // if (gaia_cookie_manager_service_)
+  //    gaia_cookie_manager_service_->AddObserver(this);
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
   // in about:sync.
   ClearStaleErrors();
 
   sync_prefs_.AddSyncPrefObserver(this);
 
+  // Only for UMA purposes :(
   SyncInitialState sync_state = CAN_START;
-  if (!IsSignedIn()) {
+  /*if (!IsSignedIn()) {
     sync_state = NOT_SIGNED_IN;
-  } else if (IsManaged()) {
+  } else*/ if (IsManaged()) {
     sync_state = IS_MANAGED;
   } else if (!IsSyncAllowedByPlatform()) {
     // This case should currently never be hit, as Android's master sync isn't
     // plumbed into PSS until after this function. See http://crbug.com/568771.
     sync_state = NOT_ALLOWED_BY_PLATFORM;
   } else if (!IsSyncRequested()) {
     if (IsFirstSetupComplete()) {
       sync_state = NOT_REQUESTED;
     } else {
       sync_state = NOT_REQUESTED_NOT_SETUP;
     }
   } else if (!IsFirstSetupComplete()) {
     sync_state = NEEDS_CONFIRMATION;
   }
   UMA_HISTOGRAM_ENUMERATION("Sync.InitialState", sync_state,
                             SYNC_INITIAL_STATE_LIMIT);
 
   // If sync isn't allowed, the only thing to do is to turn it off.
   if (!IsSyncAllowed()) {
     // Only clear data if disallowed by policy.
     RequestStop(IsManaged() ? CLEAR_DATA : KEEP_DATA);
     return;
   }
 
-  RegisterAuthNotifications();
+  // ### We should do this only if needed.
+  // RegisterAuthNotifications();
 
-  if (!IsSignedIn()) {
-    // Clean up in case of previous crash during signout.
-    StopImpl(CLEAR_DATA);
-  }
+  // ### We should do this only if needed.
+  // if (!IsSignedIn()) {
+  //   // Clean up in case of previous crash during signout.
+  //   StopImpl(CLEAR_DATA);
+  // }
 
 #if defined(OS_CHROMEOS)
   std::string bootstrap_token = sync_prefs_.GetEncryptionBootstrapToken();
   if (bootstrap_token.empty()) {
     sync_prefs_.SetEncryptionBootstrapToken(
         sync_prefs_.GetSpareBootstrapToken());
   }
 #endif
 
 #if !defined(OS_ANDROID)
   DCHECK(sync_error_controller_ == NULL)
       << "Initialize() called more than once.";
   sync_error_controller_.reset(new SyncErrorController(this));
   AddObserver(sync_error_controller_.get());
 #endif
 
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&ProfileSyncService::OnMemoryPressure,
                  sync_enabled_weak_factory_.GetWeakPtr())));
   startup_controller_->Reset(GetRegisteredDataTypes());
 
-  // Auto-start means means the first time the profile starts up, sync should
-  // start up immediately.
+  // Auto-start means the first time the profile starts up, sync should start up
+  // immediately.
   if (start_behavior_ == AUTO_START && IsSyncRequested() &&
       !IsFirstSetupComplete()) {
     startup_controller_->TryStartImmediately();
   } else {
     startup_controller_->TryStart();
   }
 }
 
 void ProfileSyncService::StartSyncingWithServer() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 100 matching lines @@
 
 bool ProfileSyncService::ShouldDeleteSyncFolder() {
   return !IsFirstSetupComplete();
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
   if (!backend_) {
     NOTREACHED();
     return;
   }
+  LOG(ERROR) << "@@@ ProfileSyncService::InitializeBackend";
 
-  SyncCredentials credentials = GetCredentials();
+  // ### Only do this if needed.
+  SyncCredentials credentials;// = GetCredentials();
 
   if (delete_stale_data)
     ClearStaleErrors();
 
+  // ### Only do this if needed.
   SyncBackendHost::HttpPostProviderFactoryGetter
       http_post_provider_factory_getter =
           base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
                      base::Unretained(network_resources_.get()),
                      url_request_context_, network_time_update_callback_);
 
   backend_->Initialize(
       this, std::move(sync_thread_), db_thread_, file_thread_,
       GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(),
       credentials, delete_stale_data,
@@ skipping 436 matching lines @@
   std::vector<gaia::ListedAccount> accounts;
   std::vector<gaia::ListedAccount> signed_out_accounts;
   GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
   if (gaia_cookie_manager_service_ &&
       gaia_cookie_manager_service_->ListAccounts(
           &accounts, &signed_out_accounts, "ChromiumProfileSyncService")) {
     OnGaiaAccountsInCookieUpdated(accounts, signed_out_accounts, error);
   }
 
   NotifyObservers();
+  RequestStart();
 }
 
 void ProfileSyncService::OnBackendInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     const std::string& cache_guid,
     bool success) {
   UpdateBackendInitUMA(success);
+  LOG(ERROR) << "@@@@ ProfileSyncService::OnBackendInitialized is " << success;
 
   if (!success) {
     // Something went unexpectedly wrong.  Play it safe: stop syncing at once
     // and surface error UI to alert the user sync has stopped.
     // Keep the directory around for now so that on restart we will retry
     // again and potentially succeed in presence of transient file IO failures
     // or permissions issues, etc.
     //
     // TODO(rlarocque): Consider making this UnrecoverableError less special.
     // Unlike every other UnrecoverableError, it does not delete our sync data.
@@ skipping 406 matching lines @@
     migrator_->OnConfigureDone(result);
     return;
   }
 
   if (catch_up_configure_in_progress_) {
     catch_up_configure_in_progress_ = false;
     ClearAndRestartSyncForPassphraseEncryption();
     return;
   }
 
+  LOG(ERROR) << "@@@ Start syncing";
   StartSyncingWithServer();
 }
 
 void ProfileSyncService::OnConfigureStart() {
   sync_configure_start_time_ = base::Time::Now();
   NotifyObservers();
 }
 
 ProfileSyncService::SyncStatusSummary
 ProfileSyncService::QuerySyncStatusSummary() {
@@ skipping 93 matching lines @@
          data_type_manager_->state() != DataTypeManager::STOPPED;
 }
 
 void ProfileSyncService::TriggerRefresh(const syncer::ModelTypeSet& types) {
   if (backend_initialized_)
     backend_->TriggerRefresh(types);
 }
 
 bool ProfileSyncService::IsSignedIn() const {
   // Sync is logged in if there is a non-empty effective account id.
-  return !signin_->GetAccountIdToUse().empty();
+  NOTREACHED() << "@@@ WHy do you even ask";
+  return true;
+  //return !signin_->GetAccountIdToUse().empty();
 }
 
 bool ProfileSyncService::CanBackendStart() const {
-  return CanSyncStart() && oauth2_token_service_ &&
+  // ### Only if needed.
+  return CanSyncStart() /*&& oauth2_token_service_ &&
          oauth2_token_service_->RefreshTokenIsAvailable(
-             signin_->GetAccountIdToUse());
+             signin_->GetAccountIdToUse())*/;
 }
 
 bool ProfileSyncService::IsBackendInitialized() const {
   return backend_initialized_;
 }
 
 bool ProfileSyncService::ConfigurationDone() const {
   return data_type_manager_ &&
          data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }
@@ skipping 762 matching lines @@
   return sync_prefs_.IsSyncRequested();
 }
 
 SigninManagerBase* ProfileSyncService::signin() const {
   if (!signin_)
     return NULL;
   return signin_->GetOriginal();
 }
 
 void ProfileSyncService::RequestStart() {
+  LOG(ERROR) << "@@@@ Requesting start";
   if (!IsSyncAllowed()) {
     // Sync cannot be requested if it's not allowed.
     return;
   }
   DCHECK(sync_client_);
   if (!IsSyncRequested()) {
     sync_prefs_.SetSyncRequested(true);
     NotifyObservers();
   }
   startup_controller_->TryStartImmediately();
@@ skipping 82 matching lines @@
 void ProfileSyncService::OverrideNetworkResourcesForTest(
     std::unique_ptr<syncer::NetworkResources> network_resources) {
   network_resources_ = std::move(network_resources);
 }
 
 bool ProfileSyncService::HasSyncingBackend() const {
   return backend_ != NULL;
 }
 
 void ProfileSyncService::UpdateFirstSyncTimePref() {
-  if (!IsSignedIn()) {
+  // ### Only if needed.
+  /*if (!IsSignedIn()) {
     sync_prefs_.ClearFirstSyncTime();
-  } else if (sync_prefs_.GetFirstSyncTime().is_null()) {
+  } else*/ if (sync_prefs_.GetFirstSyncTime().is_null()) {
     // Set if not set before and it's syncing now.
     sync_prefs_.SetFirstSyncTime(base::Time::Now());
   }
 }
 
 void ProfileSyncService::FlushDirectory() const {
   // backend_initialized_ implies backend_ isn't NULL and the manager exists.
   // If sync is not initialized yet, we fail silently.
   if (backend_initialized_)
     backend_->FlushDirectory();
@@ skipping 81 matching lines @@
   if (--outstanding_setup_in_progress_handles_ != 0)
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }