content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/browser/streams/stream.cc

 // Copyright (c) 2013 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 "content/browser/streams/stream.h"
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/browser/streams/stream_handle_impl.h"
 #include "content/browser/streams/stream_read_observer.h"
 #include "content/browser/streams/stream_registry.h"
 #include "content/browser/streams/stream_write_observer.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 
 namespace {
 // Start throttling the connection at about 1MB.
 const size_t kDeferSizeThreshold = 40 * 32768;
 }
 
 namespace content {
 
 Stream::Stream(StreamRegistry* registry,
                StreamWriteObserver* write_observer,
                const GURL& url)
     : can_add_data_(true),
       url_(url),
       data_length_(0),
       data_bytes_read_(0),
       last_total_buffered_bytes_(0),
       registry_(registry),
       read_observer_(NULL),
       write_observer_(write_observer),
       stream_handle_(NULL),
       weak_ptr_factory_(this) {
-  CreateByteStream(base::MessageLoopProxy::current(),
-                   base::MessageLoopProxy::current(),
-                   kDeferSizeThreshold,
-                   &writer_,
-                   &reader_);
+  CreateByteStream(base::ThreadTaskRunnerHandle::Get(),
+                   base::ThreadTaskRunnerHandle::Get(), kDeferSizeThreshold,
+                   &writer_, &reader_);
 
   // Setup callback for writing.
   writer_->RegisterCallback(base::Bind(&Stream::OnSpaceAvailable,
                                        weak_ptr_factory_.GetWeakPtr()));
   reader_->RegisterCallback(base::Bind(&Stream::OnDataAvailable,
                                        weak_ptr_factory_.GetWeakPtr()));
 
   registry_->RegisterStream(this);
 }
 
@@ skipping 62 matching lines @@
 }
 
 void Stream::Finalize() {
   if (!writer_.get())
     return;
 
   writer_->Close(0);
   writer_.reset();
 
   // Continue asynchronously.
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&Stream::OnDataAvailable, weak_ptr_factory_.GetWeakPtr()));
 }
 
 Stream::StreamState Stream::ReadRawData(net::IOBuffer* buf,
                                         int buf_size,
                                         int* bytes_read) {
   DCHECK(buf);
   DCHECK(bytes_read);
 
@@ skipping 58 matching lines @@
     read_observer_->OnDataAvailable(this);
 }
 
 void Stream::ClearBuffer() {
   data_ = NULL;
   data_length_ = 0;
   data_bytes_read_ = 0;
 }
 
 }  // namespace content