[Sync] Add cookie jar mismatch logging

components/browser_sync/browser/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/browser/profile_sync_service.h"
 
 #include <stddef.h>
 #include <cstddef>
 #include <map>
 #include <utility>
@@ skipping 162 matching lines @@
           error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT &&
           error.action != syncer::RESET_LOCAL_SYNC_DATA);
 }
 
 ProfileSyncService::InitParams::InitParams() = default;
 ProfileSyncService::InitParams::~InitParams() = default;
 ProfileSyncService::InitParams::InitParams(InitParams&& other)  // NOLINT
     : sync_client(std::move(other.sync_client)),
       signin_wrapper(std::move(other.signin_wrapper)),
       oauth2_token_service(other.oauth2_token_service),
+      gaia_cookie_manager_service(other.gaia_cookie_manager_service),
       start_behavior(other.start_behavior),
       network_time_update_callback(
           std::move(other.network_time_update_callback)),
       base_directory(std::move(other.base_directory)),
       url_request_context(std::move(other.url_request_context)),
       debug_identifier(std::move(other.debug_identifier)),
       channel(other.channel),
       db_thread(std::move(other.db_thread)),
       file_thread(std::move(other.file_thread)),
       blocking_pool(other.blocking_pool) {}
@@ skipping 25 matching lines @@
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       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),
       directory_path_(
           base_directory_.Append(base::FilePath(kSyncDataFolderName))),
       catch_up_configure_in_progress_(false),
       passphrase_prompt_triggered_by_version_(false),
       weak_factory_(this),
       startup_controller_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();
 }
 
 void ProfileSyncService::Initialize() {
@@ skipping 41 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 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);
 
   SyncInitialState sync_state = CAN_START;
   if (!IsSignedIn()) {
     sync_state = NOT_SIGNED_IN;
@@ skipping 646 matching lines @@
   }
 
   // Auto-start means IsFirstSetupComplete gets set automatically.
   if (start_behavior_ == AUTO_START && !IsFirstSetupComplete()) {
     // This will trigger a configure if it completes setup.
     SetFirstSetupComplete();
   } else if (CanConfigureDataTypes()) {
     ConfigureDataTypeManager();
   }
 
+  // Check for a cookie jar mismatch.
+  std::vector<gaia::ListedAccount> accounts;
+  GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
+  if (gaia_cookie_manager_service_ &&
+      gaia_cookie_manager_service_->ListAccounts(&accounts)) {
+    OnGaiaAccountsInCookieUpdated(accounts, error);
+  }
+
   NotifyObservers();
 }
 
 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);
@@ skipping 1099 matching lines @@
 }
 
 void ProfileSyncService::GoogleSignedOut(const std::string& account_id,
                                          const std::string& username) {
   sync_disabled_by_admin_ = false;
   UMA_HISTOGRAM_ENUMERATION("Sync.StopSource", syncer::SIGN_OUT,
                             syncer::STOP_SOURCE_LIMIT);
   RequestStop(CLEAR_DATA);
 }
 
+void ProfileSyncService::OnGaiaAccountsInCookieUpdated(
+    const std::vector<gaia::ListedAccount>& accounts,
+    const GoogleServiceAuthError& error) {
+  if (!IsBackendInitialized())
+    return;
+
+  bool cookie_mismatch = true;
+  std::string account_id = signin_->GetAccountIdToUse();
+
+  // Iterate through list of accounts, looking for current sync account.
+  for (const auto& account : accounts) {
+    if (account.gaia_id == account_id) {
+      cookie_mismatch = false;
+      break;
+    }
+  }
+
+  DVLOG(1) << "Cookie jar mismatch: " << cookie_mismatch;
+  backend_->OnCookieJarChanged(cookie_mismatch);
+}
+
 void ProfileSyncService::AddObserver(
     sync_driver::SyncServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ProfileSyncService::RemoveObserver(
     sync_driver::SyncServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 376 matching lines @@
 }
 
 std::string ProfileSyncService::unrecoverable_error_message() const {
   return unrecoverable_error_message_;
 }
 
 tracked_objects::Location ProfileSyncService::unrecoverable_error_location()
     const {
   return unrecoverable_error_location_;
 }