Remove base/move.h

mojo/public/cpp/bindings/associated_interface_ptr.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 MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/bindings/lib/associated_interface_ptr_state.h"
 
 namespace mojo {
 
 // Represents the client side of an associated interface. It is similar to
 // InterfacePtr, except that it doesn't own a message pipe handle.
 template <typename Interface>
 class AssociatedInterfacePtr {
-  DISALLOW_COPY_AND_ASSIGN_WITH_MOVE_FOR_BIND(AssociatedInterfacePtr)
-
  public:
   // Constructs an unbound AssociatedInterfacePtr.
   AssociatedInterfacePtr() {}
   AssociatedInterfacePtr(decltype(nullptr)) {}
 
   AssociatedInterfacePtr(AssociatedInterfacePtr&& other) {
     internal_state_.Swap(&other.internal_state_);
   }
 
   AssociatedInterfacePtr& operator=(AssociatedInterfacePtr&& other) {
@@ skipping 110 matching lines @@
   }
 
   // DO NOT USE. Exposed only for internal use and for testing.
   internal::AssociatedInterfacePtrState<Interface>* internal_state() {
     return &internal_state_;
   }
 
   // Allow AssociatedInterfacePtr<> to be used in boolean expressions, but not
   // implicitly convertible to a real bool (which is dangerous).
  private:
+  // TODO(dcheng): Use an explicit conversion operator.
   typedef internal::AssociatedInterfacePtrState<Interface>
       AssociatedInterfacePtr::*Testable;
 
  public:
   operator Testable() const {
     return internal_state_.is_bound() ? &AssociatedInterfacePtr::internal_state_
                                       : nullptr;
   }
 
  private:
   // Forbid the == and != operators explicitly, otherwise AssociatedInterfacePtr
   // will be converted to Testable to do == or != comparison.
   template <typename T>
   bool operator==(const AssociatedInterfacePtr<T>& other) const = delete;
   template <typename T>
   bool operator!=(const AssociatedInterfacePtr<T>& other) const = delete;
 
   typedef internal::AssociatedInterfacePtrState<Interface> State;
   mutable State internal_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(AssociatedInterfacePtr);
 };
 
 // Creates an associated interface. The output |ptr| should be used locally
 // while the returned request should be passed through the message pipe endpoint
 // referred to by |associated_group| to setup the corresponding asssociated
 // interface implementation at the remote side.
 //
 // NOTE: |ptr| should NOT be used to make calls before the request is sent.
 // Violating that will cause the message pipe to be closed. On the other hand,
 // as soon as the request is sent, |ptr| is usable. There is no need to wait
 // until the request is bound to an implementation at the remote side.
 template <typename Interface>
 AssociatedInterfaceRequest<Interface> GetProxy(
     AssociatedInterfacePtr<Interface>* ptr,
     AssociatedGroup* group,
     scoped_refptr<base::SingleThreadTaskRunner> runner =
         base::ThreadTaskRunnerHandle::Get()) {
   AssociatedInterfaceRequest<Interface> request;
   AssociatedInterfacePtrInfo<Interface> ptr_info;
   group->CreateAssociatedInterface(AssociatedGroup::WILL_PASS_REQUEST,
                                    &ptr_info, &request);
 
   ptr->Bind(std::move(ptr_info), std::move(runner));
   return request;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_