Replace MessageLoopProxy with ThreadTaskRunnerHandle in src/sync/.

sync/internal_api/attachments/fake_attachment_store.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 "sync/internal_api/public/attachments/fake_attachment_store.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "sync/api/attachments/attachment.h"
 
 namespace syncer {
 
 // Backend is where all the work happens.
 class FakeAttachmentStore::Backend
     : public base::RefCountedThreadSafe<FakeAttachmentStore::Backend> {
  public:
   // Construct a Backend that posts its results to |frontend_task_runner|.
   Backend(
@@ skipping 66 matching lines @@
     AttachmentMap::iterator attachments_iter = attachments_.find(*ids_iter);
     if (attachments_iter != attachments_.end()) {
       attachments_.erase(attachments_iter);
     }
   }
   frontend_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
 }
 
 FakeAttachmentStore::FakeAttachmentStore(
     const scoped_refptr<base::SequencedTaskRunner>& backend_task_runner)
-    : backend_(new Backend(base::MessageLoopProxy::current())),
+    : backend_(new Backend(base::ThreadTaskRunnerHandle::Get())),
       backend_task_runner_(backend_task_runner) {}
 
 FakeAttachmentStore::~FakeAttachmentStore() {}
 
 void FakeAttachmentStore::Read(const AttachmentIdList& ids,
                                const ReadCallback& callback) {
   backend_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeAttachmentStore::Backend::Read, backend_, ids, callback));
 }
 
 void FakeAttachmentStore::Write(const AttachmentList& attachments,
                                 const WriteCallback& callback) {
   backend_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeAttachmentStore::Backend::Write,
                  backend_,
                  attachments,
                  callback));
 }
 
 void FakeAttachmentStore::Drop(const AttachmentIdList& ids,
                                const DropCallback& callback) {
   backend_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeAttachmentStore::Backend::Drop, backend_, ids, callback));
 }
 
 }  // namespace syncer