Remove MessageLoop destruction observer from hid_connection_win.cc

device/hid/hid_connection_win.cc

 // Copyright (c) 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 "device/hid/hid_connection_win.h"
 
 #include <cstring>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/win/object_watcher.h"
 #include "components/device_event_log/device_event_log.h"
 
 #define INITGUID
 
 #include <windows.h>
 #include <hidclass.h>
 
 extern "C" {
 #include <hidsdi.h>
 }
 
 #include <setupapi.h>
 #include <winioctl.h>
 
 namespace device {
 
-class PendingHidTransfer : public base::win::ObjectWatcher::Delegate,
-                           public base::MessageLoop::DestructionObserver {
+class PendingHidTransfer : public base::win::ObjectWatcher::Delegate {
  public:
   typedef base::OnceCallback<void(PendingHidTransfer*, bool)> Callback;
 
   PendingHidTransfer(scoped_refptr<net::IOBuffer> buffer, Callback callback);
   ~PendingHidTransfer() override;
 
   void TakeResultFromWindowsAPI(BOOL result);
 
   OVERLAPPED* GetOverlapped() { return &overlapped_; }
 
   // Implements base::win::ObjectWatcher::Delegate.
   void OnObjectSignaled(HANDLE object) override;
 
-  // Implements base::MessageLoop::DestructionObserver
-  void WillDestroyCurrentMessageLoop() override;
-
  private:
   // The buffer isn't used by this object but it's important that a reference
   // to it is held until the transfer completes.
   scoped_refptr<net::IOBuffer> buffer_;
   Callback callback_;
   OVERLAPPED overlapped_;
   base::win::ScopedHandle event_;
   base::win::ObjectWatcher watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingHidTransfer);
 };
 
 PendingHidTransfer::PendingHidTransfer(scoped_refptr<net::IOBuffer> buffer,
                                        PendingHidTransfer::Callback callback)
     : buffer_(buffer),
       callback_(std::move(callback)),
       event_(CreateEvent(NULL, FALSE, FALSE, NULL)) {
   memset(&overlapped_, 0, sizeof(OVERLAPPED));
   overlapped_.hEvent = event_.Get();
 }
 
 PendingHidTransfer::~PendingHidTransfer() {
-  base::MessageLoop::current()->RemoveDestructionObserver(this);
   if (callback_)
     std::move(callback_).Run(this, false);
 }
 
 void PendingHidTransfer::TakeResultFromWindowsAPI(BOOL result) {
   if (result) {
     std::move(callback_).Run(this, true);
   } else if (GetLastError() == ERROR_IO_PENDING) {
-    base::MessageLoop::current()->AddDestructionObserver(this);
     watcher_.StartWatchingOnce(event_.Get(), this);
   } else {
     HID_PLOG(EVENT) << "HID transfer failed";
     std::move(callback_).Run(this, false);
   }
 }
 
 void PendingHidTransfer::OnObjectSignaled(HANDLE event_handle) {
   std::move(callback_).Run(this, true);
 }
 
-void PendingHidTransfer::WillDestroyCurrentMessageLoop() {
-  watcher_.StopWatching();
-  std::move(callback_).Run(this, false);
-}
-
 HidConnectionWin::HidConnectionWin(scoped_refptr<HidDeviceInfo> device_info,
                                    base::win::ScopedHandle file)
-    : HidConnection(device_info), file_(std::move(file)) {}
+    : HidConnection(std::move(device_info)), file_(std::move(file)) {}
 
 HidConnectionWin::~HidConnectionWin() {
   DCHECK(!file_.IsValid());
   DCHECK(transfers_.empty());
 }
 
 void HidConnectionWin::PlatformClose() {
   CancelIo(file_.Get());
   file_.Close();
   transfers_.clear();
@@ skipping 135 matching lines @@
       [transfer](const std::unique_ptr<PendingHidTransfer>& this_transfer) {
         return transfer == this_transfer.get();
       });
   DCHECK(it != transfers_.end());
   std::unique_ptr<PendingHidTransfer> saved_transfer = std::move(*it);
   transfers_.erase(it);
   return saved_transfer;
 }
 
 }  // namespace device