[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/notifier/chrome_invalidation_client.cc

 // Copyright (c) 2011 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/notifier/chrome_invalidation_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 111 matching lines @@
   invalidation_client_->Stop();
 
   invalidation_client_.reset();
   state_writer_ = NULL;
   listener_ = NULL;
 
   invalidation_version_tracker_.Reset();
   max_invalidation_versions_.clear();
 }
 
-void ChromeInvalidationClient::RegisterTypes(syncable::ModelEnumSet types) {
+void ChromeInvalidationClient::RegisterTypes(syncable::ModelTypeSet types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   registered_types_ = types;
   if (ticl_ready_ && registration_manager_.get()) {
     registration_manager_->SetRegisteredTypes(registered_types_);
   }
   // TODO(akalin): Clear invalidation versions for unregistered types.
 }
 
 void ChromeInvalidationClient::Ready(
     invalidation::InvalidationClient* client) {
@@ skipping 39 matching lines @@
   invalidation_version_tracker_.Call(
       FROM_HERE,
       &InvalidationVersionTracker::SetMaxVersion,
       model_type, invalidation.version());
 
   std::string payload;
   // payload() CHECK()'s has_payload(), so we must check it ourselves first.
   if (invalidation.has_payload())
     payload = invalidation.payload();
 
-  EmitInvalidation(syncable::ModelEnumSet(model_type), payload);
+  EmitInvalidation(syncable::ModelTypeSet(model_type), payload);
   // TODO(akalin): We should really acknowledge only after we get the
   // updates from the sync server. (see http://crbug.com/78462).
   client->Acknowledge(ack_handle);
 }
 
 void ChromeInvalidationClient::InvalidateUnknownVersion(
     invalidation::InvalidationClient* client,
     const invalidation::ObjectId& object_id,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   DVLOG(1) << "InvalidateUnknownVersion";
 
   syncable::ModelType model_type;
   if (!ObjectIdToRealModelType(object_id, &model_type)) {
     LOG(WARNING) << "Could not get invalidation model type; "
                  << "invalidating everything";
     EmitInvalidation(registered_types_, std::string());
     client->Acknowledge(ack_handle);
     return;
   }
 
-  EmitInvalidation(syncable::ModelEnumSet(model_type), "");
+  EmitInvalidation(syncable::ModelTypeSet(model_type), "");
   // TODO(akalin): We should really acknowledge only after we get the
   // updates from the sync server. (see http://crbug.com/78462).
   client->Acknowledge(ack_handle);
 }
 
 // This should behave as if we got an invalidation with version
 // UNKNOWN_OBJECT_VERSION for all known data types.
 void ChromeInvalidationClient::InvalidateAll(
     invalidation::InvalidationClient* client,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   DVLOG(1) << "InvalidateAll";
   EmitInvalidation(registered_types_, std::string());
   // TODO(akalin): We should really acknowledge only after we get the
   // updates from the sync server. (see http://crbug.com/76482).
   client->Acknowledge(ack_handle);
 }
 
 void ChromeInvalidationClient::EmitInvalidation(
-    syncable::ModelEnumSet types, const std::string& payload) {
+    syncable::ModelTypeSet types, const std::string& payload) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   syncable::ModelTypePayloadMap type_payloads =
       syncable::ModelTypePayloadMapFromEnumSet(types, payload);
   listener_->OnInvalidate(type_payloads);
 }
 
 void ChromeInvalidationClient::InformRegistrationStatus(
       invalidation::InvalidationClient* client,
       const invalidation::ObjectId& object_id,
       InvalidationListener::RegistrationState new_state) {
@@ skipping 60 matching lines @@
   // TODO(ghc): handle the error.
 }
 
 void ChromeInvalidationClient::WriteState(const std::string& state) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(state_writer_);
   state_writer_->WriteState(state);
 }
 
 }  // namespace sync_notifier