Remove use of MessageLoopProxy

mojo/application/content_handler_factory.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 "mojo/application/content_handler_factory.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/common/message_pump_mojo.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/interface_factory_impl.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/services/content_handler/public/interfaces/content_handler.mojom.h"
 
 namespace mojo {
 
 namespace {
 
 class ApplicationThread : public base::PlatformThread::Delegate {
  public:
   ApplicationThread(
-      scoped_refptr<base::MessageLoopProxy> handler_thread,
+      scoped_refptr<base::SingleThreadTaskRunner> handler_thread,
       const base::Callback<void(ApplicationThread*)>& termination_callback,
       ContentHandlerFactory::Delegate* handler_delegate,
       InterfaceRequest<Application> application_request,
       URLResponsePtr response)
       : handler_thread_(handler_thread),
         termination_callback_(termination_callback),
         handler_delegate_(handler_delegate),
         application_request_(application_request.Pass()),
         response_(response.Pass()) {}
 
  private:
   void ThreadMain() override {
     base::PlatformThread::SetName(response_->url);
     handler_delegate_->RunApplication(application_request_.Pass(),
                                       response_.Pass());
     handler_thread_->PostTask(FROM_HERE,
                               base::Bind(termination_callback_, this));
   }
 
-  scoped_refptr<base::MessageLoopProxy> handler_thread_;
+  scoped_refptr<base::SingleThreadTaskRunner> handler_thread_;
   base::Callback<void(ApplicationThread*)> termination_callback_;
   ContentHandlerFactory::Delegate* handler_delegate_;
   InterfaceRequest<Application> application_request_;
   URLResponsePtr response_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationThread);
 };
 
 class ContentHandlerImpl : public ContentHandler {
  public:
@@ skipping 12 matching lines @@
       base::PlatformThread::Join(thread.second);
       delete thread.first;
     }
   }
 
  private:
   // Overridden from ContentHandler:
   void StartApplication(InterfaceRequest<Application> application_request,
                         URLResponsePtr response) override {
     ApplicationThread* thread = new ApplicationThread(
-        base::MessageLoopProxy::current(),
+        base::ThreadTaskRunnerHandle::Get(),
         base::Bind(&ContentHandlerImpl::OnThreadEnd,
                    weak_factory_.GetWeakPtr()),
         delegate_, application_request.Pass(), response.Pass());
     base::PlatformThreadHandle handle;
     bool launched = base::PlatformThread::Create(0, thread, &handle);
     DCHECK(launched);
     active_threads_[thread] = handle;
   }
 
   void OnThreadEnd(ApplicationThread* thread) {
@@ skipping 30 matching lines @@
   if (application)
     loop.Run();
 }
 
 void ContentHandlerFactory::Create(ApplicationConnection* connection,
                                    InterfaceRequest<ContentHandler> request) {
   new ContentHandlerImpl(delegate_, request.Pass());
 }
 
 }  // namespace mojo