Make use of InvalidationService

chrome/browser/sync/profile_sync_service_harness.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_harness.h"
 
 #include <cstddef>
 #include <iterator>
 #include <ostream>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
+#include "chrome/browser/invalidation/p2p_invalidation_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager_base.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/sync/about_sync_util.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "sync/internal_api/public/base/progress_marker_map.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/internal_api/public/util/sync_string_conversions.h"
 
 using syncer::sessions::SyncSessionSnapshot;
+using invalidation::P2PInvalidationService;
 
 // TODO(rsimha): Remove the following lines once crbug.com/91863 is fixed.
 // The amount of time for which we wait for a live sync operation to complete.
 static const int kLiveSyncOperationTimeoutMs = 45000;
 
 // The amount of time we wait for test cases that verify exponential backoff.
 static const int kExponentialBackoffVerificationTimeoutMs = 60000;
 
 // Simple class to implement a timeout using PostDelayedTask.  If it is not
 // aborted before picked up by a message queue, then it asserts with the message
@@ skipping 48 matching lines @@
     }
   }
 }
 
 bool StateChangeTimeoutEvent::Abort() {
   aborted_ = true;
   caller_ = NULL;
   return !did_timeout_;
 }
 
+// static
+ProfileSyncServiceHarness* ProfileSyncServiceHarness::Create(
+    Profile* profile,
+    const std::string& username,
+    const std::string& password) {
+  return new ProfileSyncServiceHarness(profile, username, password, NULL);
+}
+
+// static
+ProfileSyncServiceHarness* ProfileSyncServiceHarness::CreateForIntegrationTest(
+    Profile* profile,
+    const std::string& username,
+    const std::string& password,
+    P2PInvalidationService* p2p_invalidation_service) {
+  return new ProfileSyncServiceHarness(profile,
+                                       username,
+                                       password,
+                                       p2p_invalidation_service);
+}
+
 ProfileSyncServiceHarness::ProfileSyncServiceHarness(
     Profile* profile,
     const std::string& username,
-    const std::string& password)
+    const std::string& password,
+    P2PInvalidationService* p2p_invalidation_service)
     : waiting_for_encryption_type_(syncer::UNSPECIFIED),
       wait_state_(INITIAL_WAIT_STATE),
       profile_(profile),
       service_(NULL),
+      p2p_invalidation_service_(p2p_invalidation_service),
       progress_marker_partner_(NULL),
       username_(username),
       password_(password),
       profile_debug_name_(profile->GetDebugName()),
       waiting_for_status_change_(false) {
   if (IsSyncAlreadySetup()) {
     service_ = ProfileSyncServiceFactory::GetInstance()->GetForProfile(
         profile_);
     service_->AddObserver(this);
     ignore_result(TryListeningToMigrationEvents());
     wait_state_ = FULLY_SYNCED;
   }
 }
 
 ProfileSyncServiceHarness::~ProfileSyncServiceHarness() {
   if (service_->HasObserver(this))
     service_->RemoveObserver(this);
 }
 
-// static
-ProfileSyncServiceHarness* ProfileSyncServiceHarness::CreateAndAttach(
-    Profile* profile) {
-  ProfileSyncServiceFactory* f = ProfileSyncServiceFactory::GetInstance();
-  if (!f->HasProfileSyncService(profile)) {
-    NOTREACHED() << "Profile has never signed into sync.";
-    return NULL;
-  }
-  return new ProfileSyncServiceHarness(profile, std::string(), std::string());
-}
-
 void ProfileSyncServiceHarness::SetCredentials(const std::string& username,
                                                const std::string& password) {
   username_ = username;
   password_ = password;
 }
 
 bool ProfileSyncServiceHarness::IsSyncAlreadySetup() {
   return ProfileSyncServiceFactory::GetInstance()->HasProfileSyncService(
       profile_);
 }
@@ skipping 318 matching lines @@
       // classes using the the UI message loop.  Defer to their handling.
       break;
   }
   return original_wait_state != wait_state_;
 }
 
 void ProfileSyncServiceHarness::OnStateChanged() {
   RunStateChangeMachine();
 }
 
+void ProfileSyncServiceHarness::OnSyncCycleCompleted() {
+  // Integration tests still use p2p notifications.
+  const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
+  bool is_notifiable_commit =
+      (snap.model_neutral_state().num_successful_commits > 0);
+  if (is_notifiable_commit && p2p_invalidation_service_) {
+    const syncer::ObjectIdInvalidationMap& invalidation_map =
+        ModelTypeInvalidationMapToObjectIdInvalidationMap(
+            snap.source().types);
+    p2p_invalidation_service_->SendInvalidation(invalidation_map);
+  }
+
+  OnStateChanged();
+}
+
 void ProfileSyncServiceHarness::OnMigrationStateChange() {
   // Update migration state.
   if (HasPendingBackendMigration()) {
     // Merge current pending migration types into
     // |pending_migration_types_|.
     pending_migration_types_.PutAll(
         service()->GetBackendMigratorForTest()->
             GetPendingMigrationTypesForTest());
     DVLOG(1) << profile_debug_name_ << ": new pending migration types "
              << syncer::ModelTypeSetToString(pending_migration_types_);
@@ skipping 634 matching lines @@
 
 std::string ProfileSyncServiceHarness::GetServiceStatus() {
   scoped_ptr<DictionaryValue> value(
       sync_ui_util::ConstructAboutInformation(service_));
   std::string service_status;
   base::JSONWriter::WriteWithOptions(value.get(),
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &service_status);
   return service_status;
 }