chrome/browser: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/browser/devtools/device/usb/android_usb_browsertest.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 <algorithm>
 
 #include "base/containers/scoped_ptr_hash_map.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/devtools/device/adb/mock_adb_server.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
 #include "chrome/browser/devtools/device/usb/android_usb_device.h"
 #include "chrome/browser/devtools/device/usb/usb_device_provider.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
@@ skipping 114 matching lines @@
 
   void ClaimInterface(int interface_number,
                       const ResultCallback& callback) override {
     bool success = false;
     if (device_->claimed_interfaces_.find(interface_number) ==
         device_->claimed_interfaces_.end()) {
       device_->claimed_interfaces_.insert(interface_number);
       success = true;
     }
 
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-                                           base::Bind(callback, success));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, success));
   }
 
   bool ReleaseInterface(int interface_number) override {
     if (device_->claimed_interfaces_.find(interface_number) ==
         device_->claimed_interfaces_.end())
       return false;
 
     device_->claimed_interfaces_.erase(interface_number);
     return true;
   }
@@ skipping 43 matching lines @@
         current_message_->body += std::string(buffer->data(), length);
         remaining_body_length_ -= length;
       }
 
       if (remaining_body_length_ == 0) {
         ProcessIncoming();
       }
 
       device::UsbTransferStatus status =
           broken_ ? device::USB_TRANSFER_ERROR : device::USB_TRANSFER_COMPLETED;
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, status, nullptr, 0));
       ProcessQueries();
     } else if (direction == device::USB_DIRECTION_INBOUND) {
       queries_.push(Query(callback, buffer, length));
       ProcessQueries();
     }
   }
 
   template <class D>
   void append(D data) {
@@ skipping 88 matching lines @@
       output_buffer_.push_back(0);
     }
     ProcessQueries();
   }
 
   void ProcessQueries() {
     if (!queries_.size())
       return;
     Query query = queries_.front();
     if (broken_) {
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
-          base::Bind(query.callback,
-                     device::USB_TRANSFER_ERROR,
-                     nullptr,
-                     0));
+          base::Bind(query.callback, device::USB_TRANSFER_ERROR, nullptr, 0));
     }
 
     if (query.size > output_buffer_.size())
       return;
 
     queries_.pop();
     std::copy(output_buffer_.begin(),
               output_buffer_.begin() + query.size,
               query.buffer->data());
     output_buffer_.erase(output_buffer_.begin(),
                          output_buffer_.begin() + query.size);
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(query.callback,
-                   device::USB_TRANSFER_COMPLETED,
-                   query.buffer,
-                   query.size));
-
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(query.callback, device::USB_TRANSFER_COMPLETED,
+                              query.buffer, query.size));
   }
 
   void InterruptTransfer(UsbEndpointDirection direction,
                          uint8 endpoint,
                          scoped_refptr<net::IOBuffer> buffer,
                          size_t length,
                          unsigned int timeout,
                          const TransferCallback& callback) override {}
 
   void IsochronousTransfer(UsbEndpointDirection direction,
@@ skipping 56 matching lines @@
     interface_desc.interface_class = T::kClass;
     interface_desc.interface_subclass = T::kSubclass;
     interface_desc.interface_protocol = T::kProtocol;
     interface_desc.endpoints.push_back(bulk_in);
     interface_desc.endpoints.push_back(bulk_out);
 
     config_desc_.interfaces.push_back(interface_desc);
   }
 
   void Open(const OpenCallback& callback) override {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, make_scoped_refptr(
                                             new MockUsbDeviceHandle<T>(this))));
   }
 
   const UsbConfigDescriptor* GetConfiguration() override {
     return T::kConfigured ? &config_desc_ : nullptr;
   }
 
   bool Close(scoped_refptr<UsbDeviceHandle> handle) override {
     return true;
@@ skipping 233 matching lines @@
   MockCountListenerWithReAddWhileQueued(
       DevToolsAndroidBridge* adb_bridge)
       : MockCountListener(adb_bridge),
         readded_(false) {
   }
 
   void DeviceCountChanged(int count) override {
     ++invoked_;
     if (!readded_) {
       readded_ = true;
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&MockCountListenerWithReAddWhileQueued::ReAdd,
-                     base::Unretained(this)));
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(&MockCountListenerWithReAddWhileQueued::ReAdd,
+                                base::Unretained(this)));
     } else {
       adb_bridge_->RemoveDeviceCountListener(this);
       Shutdown();
     }
   }
 
   void ReAdd() {
     adb_bridge_->RemoveDeviceCountListener(this);
     adb_bridge_->AddDeviceCountListener(this);
   }
@@ skipping 97 matching lines @@
   EXPECT_EQ(2, listener.invoked_);
   EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_);
   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 }
 
 IN_PROC_BROWSER_TEST_F(AndroidUsbTraitsTest, TestDeviceCounting) {
   MockCountListenerForCheckingTraits listener(adb_bridge_);
   adb_bridge_->AddDeviceCountListener(&listener);
   runner_->Run();
 }