components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/invalidation/sync_invalidation_listener.cc

 // Copyright 2014 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/invalidation/sync_invalidation_listener.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/location.h"
 #include "base/logging.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/tracked_objects.h"
 #include "components/invalidation/invalidation_util.h"
 #include "components/invalidation/object_id_invalidation_map.h"
 #include "components/invalidation/registration_manager.h"
 #include "google/cacheinvalidation/include/invalidation-client.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "jingle/notifier/listener/push_client.h"
 
 namespace {
 
@@ skipping 107 matching lines @@
   std::string payload;
   // payload() CHECK()'s has_payload(), so we must check it ourselves first.
   if (invalidation.has_payload())
     payload = invalidation.payload();
 
   DVLOG(2) << "Received invalidation with version " << invalidation.version()
            << " for " << ObjectIdToString(id);
 
   ObjectIdInvalidationMap invalidations;
   Invalidation inv = Invalidation::Init(id, invalidation.version(), payload);
-  inv.SetAckHandler(AsWeakPtr(), base::MessageLoopProxy::current());
+  inv.SetAckHandler(AsWeakPtr(), base::ThreadTaskRunnerHandle::Get());
   invalidations.Insert(inv);
 
   DispatchInvalidations(invalidations);
 }
 
 void SyncInvalidationListener::InvalidateUnknownVersion(
     invalidation::InvalidationClient* client,
     const invalidation::ObjectId& object_id,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateUnknownVersion";
   client->Acknowledge(ack_handle);
 
   ObjectIdInvalidationMap invalidations;
   Invalidation unknown_version = Invalidation::InitUnknownVersion(object_id);
-  unknown_version.SetAckHandler(AsWeakPtr(), base::MessageLoopProxy::current());
+  unknown_version.SetAckHandler(AsWeakPtr(),
+                                base::ThreadTaskRunnerHandle::Get());
   invalidations.Insert(unknown_version);
 
   DispatchInvalidations(invalidations);
 }
 
 // This should behave as if we got an invalidation with version
 // UNKNOWN_OBJECT_VERSION for all known data types.
 void SyncInvalidationListener::InvalidateAll(
     invalidation::InvalidationClient* client,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateAll";
   client->Acknowledge(ack_handle);
 
   ObjectIdInvalidationMap invalidations;
   for (ObjectIdSet::iterator it = registered_ids_.begin();
        it != registered_ids_.end(); ++it) {
     Invalidation unknown_version = Invalidation::InitUnknownVersion(*it);
     unknown_version.SetAckHandler(AsWeakPtr(),
-                                  base::MessageLoopProxy::current());
+                                  base::ThreadTaskRunnerHandle::Get());
     invalidations.Insert(unknown_version);
   }
 
   DispatchInvalidations(invalidations);
 }
 
 // If a handler is registered, emit right away.  Otherwise, save it for later.
 void SyncInvalidationListener::DispatchInvalidations(
     const ObjectIdInvalidationMap& invalidations) {
   DCHECK(CalledOnValidThread());
@@ skipping 162 matching lines @@
                  unacked_invalidations_map_));
 
   ObjectIdInvalidationMap object_id_invalidation_map;
   for (UnackedInvalidationsMap::iterator map_it =
        unacked_invalidations_map_.begin();
        map_it != unacked_invalidations_map_.end(); ++map_it) {
     if (registered_ids_.find(map_it->first) == registered_ids_.end()) {
       continue;
     }
     map_it->second.ExportInvalidations(AsWeakPtr(),
-                                       base::MessageLoopProxy::current(),
+                                       base::ThreadTaskRunnerHandle::Get(),
                                        &object_id_invalidation_map);
   }
 
   // There's no need to run these through DispatchInvalidations(); they've
   // already been saved to storage (that's where we found them) so all we need
   // to do now is emit them.
   EmitSavedInvalidations(object_id_invalidation_map);
 }
 
 void SyncInvalidationListener::RequestDetailedStatus(
@@ skipping 76 matching lines @@
 }
 
 void SyncInvalidationListener::OnNetworkChannelStateChanged(
     InvalidatorState invalidator_state) {
   DCHECK(CalledOnValidThread());
   push_client_state_ = invalidator_state;
   EmitStateChange();
 }
 
 }  // namespace syncer