[Chromoting] Move CreateSessionToken() next to launch process utilities.

base/win/scoped_handle.h

 // Copyright (c) 2012 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 BASE_WIN_SCOPED_HANDLE_H_
 #define BASE_WIN_SCOPED_HANDLE_H_
 
 #include <windows.h>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/move.h"
 
 namespace base {
 namespace win {
 
 // TODO(rvargas): remove this with the rest of the verifier.
 #if defined(COMPILER_MSVC)
 // MSDN says to #include <intrin.h>, but that breaks the VS2005 build.
 extern "C" {
   void* _ReturnAddress();
 }
 #define BASE_WIN_GET_CALLER _ReturnAddress()
 #elif defined(COMPILER_GCC)
 #define BASE_WIN_GET_CALLER __builtin_extract_return_addr(\\
     __builtin_return_address(0))
 #endif
 
 // Generic wrapper for raw handles that takes care of closing handles
 // automatically. The class interface follows the style of
 // the ScopedStdioHandle class with a few additions:
 //   - IsValid() method can tolerate multiple invalid handle values such as NULL
 //     and INVALID_HANDLE_VALUE (-1) for Win32 handles.
 //   - Receive() method allows to receive a handle value from a function that
 //     takes a raw handle pointer only.
 template <class Traits, class Verifier>
 class GenericScopedHandle {
+  MOVE_ONLY_TYPE_FOR_CPP_03(GenericScopedHandle, RValue)
+
  public:
   typedef typename Traits::Handle Handle;
 
   GenericScopedHandle() : handle_(Traits::NullHandle()) {}
 
   explicit GenericScopedHandle(Handle handle) : handle_(Traits::NullHandle()) {
     Set(handle);
   }
 
+  // Move constructor for C++03 move emulation of this type.
+  GenericScopedHandle(RValue& other)
+      // The type of the underlying object is GenericScopedHandle; we have to
+      // reinterpret_cast back to the original type for the call to release to
+      // be valid. (See C++11 5.2.10.7)
+      : handle_(reinterpret_cast<GenericScopedHandle&>(other).Take()) {

[jar (doing other things), 2012/08/07 01:00:30]

Should be a static_cast (possibly of pointers)?  If not, why not?

[alexeypa (please no reviews), 2012/08/07 17:55:14]

This code was copied from scoped_handle.h. It reinterpret_cast not seem to be
needed though. RValue is a structure that inherits from GenericScopedHandle
(defined by MOVE_ONLY_TYPE_FOR_CPP_03 macro). Take() should be accessible.

+  }
+
   ~GenericScopedHandle() {
     Close();
   }
 
   bool IsValid() const {
     return Traits::IsHandleValid(handle_);
   }
 
+  // Move operator= for C++03 move emulation of this type.
+  GenericScopedHandle& operator=(RValue& other) {

[jar (doing other things), 2012/08/07 01:00:30]

I'm a little surprised you didn't pass in a const ref.... but then I see you
used Swap(), which required a non-const.

It seems strange (unexpected?) that an assignment operator modifies the rvalue. 
I would (at most) have expected it to close the assigned-to handle, and replace
the rvalue's handle with an invalid handle.

Can you justify this semantic, or add a comment to that effect into the code?

[alexeypa (please no reviews), 2012/08/07 17:55:14]

This is copied from scoped_ptr too. |other| has to be modified because
operator=() passes ownership.
This will break self-assignment (when this == &other). Swap allows to avoid that
and it is also very cheap.
Added.

+    Swap(other);
+    return *this;
+  }
+
   void Set(Handle handle) {
     if (handle_ != handle) {
       Close();
 
       if (Traits::IsHandleValid(handle)) {
         handle_ = handle;
         Verifier::StartTracking(handle, this, BASE_WIN_GET_CALLER,
                                 tracked_objects::GetProgramCounter());
       }
     }
   }
 
   Handle Get() const {
     return handle_;
   }
 
   operator Handle() const {
     return handle_;
   }
 
   Handle* Receive() {
     DCHECK(!Traits::IsHandleValid(handle_)) << "Handle must be NULL";
 
     // We cannot track this case :(. Just tell the verifier about it.
     Verifier::StartTracking(INVALID_HANDLE_VALUE, this, BASE_WIN_GET_CALLER,
                             tracked_objects::GetProgramCounter());
     return &handle_;
   }
 
+  void Swap(GenericScopedHandle& other) {
+    Handle tmp = handle_;
+    handle_ = other.handle_;
+    other.handle_ = tmp;
+  }
+
   // Transfers ownership away from this object.
   Handle Take() {
     Handle temp = handle_;
     handle_ = Traits::NullHandle();
     Verifier::StopTracking(temp, this, BASE_WIN_GET_CALLER,
                            tracked_objects::GetProgramCounter());
     return temp;
   }
 
   // Explicitly closes the owned handle.
   void Close() {
     if (Traits::IsHandleValid(handle_)) {
       Verifier::StopTracking(handle_, this, BASE_WIN_GET_CALLER,
                              tracked_objects::GetProgramCounter());
 
       if (!Traits::CloseHandle(handle_))
         CHECK(false);
 
       handle_ = Traits::NullHandle();
     }
   }
 
  private:
   Handle handle_;
-
-  DISALLOW_COPY_AND_ASSIGN(GenericScopedHandle);
 };
 
 #undef BASE_WIN_GET_CALLER
 
 // The traits class for Win32 handles that can be closed via CloseHandle() API.
 class HandleTraits {
  public:
   typedef HANDLE Handle;
 
   // Closes the handle.
@@ skipping 42 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(VerifierTraits);
 };
 
 typedef GenericScopedHandle<HandleTraits, VerifierTraits> ScopedHandle;
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_SCOPED_HANDLE_WIN_H_