Revert of Remove base/move.h

content/child/scoped_web_callbacks.h

 // Copyright 2015 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.
 
 #ifndef CONTENT_CHILD_SCOPED_WEB_CALLBACKS_H_
 #define CONTENT_CHILD_SCOPED_WEB_CALLBACKS_H_
 
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
-#include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/move.h"
 #include "third_party/WebKit/public/platform/WebCallbacks.h"
 
 // A ScopedWebCallbacks is a move-only scoper which helps manage the lifetime of
 // a blink::WebCallbacks object. This is particularly useful when you're
 // simultaneously dealing with the following two conditions:
 //
 //   1. Your WebCallbacks implementation requires either onSuccess or onError to
 //      be called before it's destroyed. This is the case with
 //      CallbackPromiseAdapter for example, because its underlying
 //      ScriptPromiseResolver must be resolved or rejected before destruction.
@@ skipping 36 matching lines @@
 //
 // If the bound RespondWithSuccess callback actually runs, PassCallbacks() will
 // reliquish ownership of the WebCallbacks object to a temporary scoped_ptr
 // which will be destroyed immediately after onSuccess is called.
 //
 // If the bound RespondWithSuccess callback is instead destroyed first,
 // the ScopedWebCallbacks destructor will invoke OnCallbacksDropped, executing
 // our desired default behavior before deleting the WebCallbacks.
 template <typename CallbacksType>
 class ScopedWebCallbacks {
+  MOVE_ONLY_TYPE_FOR_CPP_03(ScopedWebCallbacks);
+
  public:
   using DestructionCallback =
       base::Callback<void(std::unique_ptr<CallbacksType> callbacks)>;
 
   ScopedWebCallbacks(std::unique_ptr<CallbacksType> callbacks,
                      const DestructionCallback& destruction_callback)
       : callbacks_(std::move(callbacks)),
         destruction_callback_(destruction_callback) {}
 
   ~ScopedWebCallbacks() {
     if (callbacks_)
       destruction_callback_.Run(std::move(callbacks_));
   }
 
   ScopedWebCallbacks(ScopedWebCallbacks&& other) { *this = std::move(other); }
 
   ScopedWebCallbacks& operator=(ScopedWebCallbacks&& other) {
     callbacks_ = std::move(other.callbacks_);
     destruction_callback_ = other.destruction_callback_;
     return *this;
   }
 
   std::unique_ptr<CallbacksType> PassCallbacks() {
     return std::move(callbacks_);
   }
 
  private:
   std::unique_ptr<CallbacksType> callbacks_;
   DestructionCallback destruction_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedWebCallbacks);
 };
 
 template <typename CallbacksType>
 ScopedWebCallbacks<CallbacksType> make_scoped_web_callbacks(
     CallbacksType* callbacks,
     const typename ScopedWebCallbacks<CallbacksType>::DestructionCallback&
         destruction_callback) {
   return ScopedWebCallbacks<CallbacksType>(base::WrapUnique(callbacks),
                                            destruction_callback);
 }
 
 #endif  // CONTENT_CHILD_SCOPED_WEB_CALLBACKS_H_