Remove base/move.h

mojo/public/cpp/bindings/struct_ptr.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_STRUCT_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_STRUCT_PTR_H_
 
 #include <new>
 
 #include "base/logging.h"
-#include "base/move.h"
+#include "base/macros.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
 namespace internal {
 
 template <typename Struct>
 class StructHelper {
  public:
   template <typename Ptr>
   static void Initialize(Ptr* ptr) {
     ptr->Initialize();
   }
 };
 
 }  // namespace internal
 
 // Smart pointer wrapping a mojom structure with move-only semantics.
 template <typename Struct>
 class StructPtr {
-  MOVE_ONLY_TYPE_FOR_CPP_03(StructPtr);
-
  public:
 
   StructPtr() : ptr_(nullptr) {}
   StructPtr(decltype(nullptr)) : ptr_(nullptr) {}
 
   ~StructPtr() { delete ptr_; }
 
   StructPtr& operator=(decltype(nullptr)) {
     reset();
     return *this;
@@ skipping 36 matching lines @@
   // that it contains Mojo handles).
   StructPtr Clone() const { return is_null() ? StructPtr() : ptr_->Clone(); }
 
   bool Equals(const StructPtr& other) const {
     if (is_null() || other.is_null())
       return is_null() && other.is_null();
     return ptr_->Equals(*other.ptr_);
   }
 
  private:
+  // TODO(dcheng): Use an explicit conversion operator.
   typedef Struct* StructPtr::*Testable;
 
  public:
   operator Testable() const { return ptr_ ? &StructPtr::ptr_ : 0; }
 
  private:
   friend class internal::StructHelper<Struct>;
 
   // Forbid the == and != operators explicitly, otherwise StructPtr will be
   // converted to Testable to do == or != comparison.
   template <typename T>
   bool operator==(const StructPtr<T>& other) const = delete;
   template <typename T>
   bool operator!=(const StructPtr<T>& other) const = delete;
 
   void Initialize() {
     DCHECK(!ptr_);
     ptr_ = new Struct();
   }
 
   void Take(StructPtr* other) {
     reset();
     Swap(other);
   }
 
   Struct* ptr_;
+
+  DISALLOW_COPY_AND_ASSIGN(StructPtr);
 };
 
 // Designed to be used when Struct is small and copyable.
 template <typename Struct>
 class InlinedStructPtr {
-  MOVE_ONLY_TYPE_FOR_CPP_03(InlinedStructPtr);
-
  public:
 
   InlinedStructPtr() : is_null_(true) {}
   InlinedStructPtr(decltype(nullptr)) : is_null_(true) {}
 
   ~InlinedStructPtr() {}
 
   InlinedStructPtr& operator=(decltype(nullptr)) {
     reset();
     return *this;
@@ skipping 36 matching lines @@
   InlinedStructPtr Clone() const {
     return is_null() ? InlinedStructPtr() : value_.Clone();
   }
   bool Equals(const InlinedStructPtr& other) const {
     if (is_null() || other.is_null())
       return is_null() && other.is_null();
     return value_.Equals(other.value_);
   }
 
  private:
+  // TODO(dcheng): Use an explicit conversion operator.
   typedef Struct InlinedStructPtr::*Testable;
 
  public:
   operator Testable() const { return is_null_ ? 0 : &InlinedStructPtr::value_; }
 
  private:
   friend class internal::StructHelper<Struct>;
 
   // Forbid the == and != operators explicitly, otherwise InlinedStructPtr will
   // be converted to Testable to do == or != comparison.
   template <typename T>
   bool operator==(const InlinedStructPtr<T>& other) const = delete;
   template <typename T>
   bool operator!=(const InlinedStructPtr<T>& other) const = delete;
 
   void Initialize() { is_null_ = false; }
 
   void Take(InlinedStructPtr* other) {
     reset();
     Swap(other);
   }
 
   mutable Struct value_;
   bool is_null_;
+
+  DISALLOW_COPY_AND_ASSIGN(InlinedStructPtr);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_STRUCT_PTR_H_