Remove old C++03 move emulation code.

storage/browser/blob/scoped_file.h

 // Copyright (c) 2013 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 STORAGE_BROWSER_BLOB_SCOPED_FILE_H_
 #define STORAGE_BROWSER_BLOB_SCOPED_FILE_H_
 
 #include <map>
 
 #include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/move.h"
 #include "storage/browser/storage_browser_export.h"
 
 namespace base {
 class TaskRunner;
 }
 
 namespace storage {
 
 // A scoped reference for a FilePath that can optionally schedule the file
 // to be deleted and/or to notify a consumer when it is going to be scoped out.
 // This class supports move semantics, i.e. consumers can call Pass() to
 // pass the ownership of ScopedFile.
 //
 // TODO(kinuko): Probably this can be moved under base or somewhere more
 // common place.
 class STORAGE_EXPORT ScopedFile {
-  // To support destructive assignment from an l-value assignment.
-  // This provides Pass() method which creates an r-value for the current
-  // instance. (See base/move.h for details)
-  MOVE_ONLY_TYPE_FOR_CPP_03(ScopedFile, RValue)
+  MOVE_ONLY_TYPE_FOR_CPP_03(ScopedFile)
 
  public:
   typedef base::Callback<void(const base::FilePath&)> ScopeOutCallback;
   typedef std::pair<ScopeOutCallback, scoped_refptr<base::TaskRunner> >
       ScopeOutCallbackPair;
   typedef std::vector<ScopeOutCallbackPair> ScopeOutCallbackList;
 
   enum ScopeOutPolicy {
     DELETE_ON_SCOPE_OUT,
     DONT_DELETE_ON_SCOPE_OUT,
   };
 
   ScopedFile();
 
   // |file_task_runner| is used to schedule a file deletion if |policy|
   // is DELETE_ON_SCOPE_OUT.
   ScopedFile(const base::FilePath& path,
              ScopeOutPolicy policy,
              const scoped_refptr<base::TaskRunner>& file_task_runner);
 
   // Move constructor and operator. The data of r-value will be transfered
   // in a destructive way. (See base/move.h)
-  ScopedFile(RValue other);
-  ScopedFile& operator=(RValue rhs) {
-    MoveFrom(*rhs.object);
+  ScopedFile(ScopedFile&& other);
+  ScopedFile& operator=(ScopedFile&& rhs) {
+    MoveFrom(rhs);
     return *this;
   }
 
   ~ScopedFile();
 
   // The |callback| is fired on |callback_runner| when the final reference
   // of this instance is released.
   // If release policy is DELETE_ON_SCOPE_OUT the
   // callback task(s) is/are posted before the deletion is scheduled.
   void AddScopeOutCallback(const ScopeOutCallback& callback,
@@ skipping 16 matching lines @@
 
   base::FilePath path_;
   ScopeOutPolicy scope_out_policy_;
   scoped_refptr<base::TaskRunner> file_task_runner_;
   ScopeOutCallbackList scope_out_callbacks_;
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_BLOB_SCOPED_FILE_H_