Adding a Set() method for copying a variant over to the ScopedVariant....

base/scoped_variant_win.h

 // Copyright (c) 2009 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_SCOPED_VARIANT_WIN_H_
 #define BASE_SCOPED_VARIANT_WIN_H_
 
 #include <windows.h>
 #include <oleauto.h>
 
@@ skipping 22 matching lines @@
   // be transferred
   explicit ScopedVariant(const wchar_t* str);
 
   // Creates a new VT_BSTR variant of a specified length.
   explicit ScopedVariant(const wchar_t* str, UINT length);
 
   // Creates a new integral type variant and assigns the value to
   // VARIANT.lVal (32 bit sized field).
   explicit ScopedVariant(int value, VARTYPE vt = VT_I4);
 
+  // VT_DISPATCH
+  explicit ScopedVariant(IDispatch* dispatch);
+
+  // VT_UNKNOWN
+  explicit ScopedVariant(IUnknown* unknown);
+
+  // Copies the variant.
+  explicit ScopedVariant(const VARIANT& var);
+
   ~ScopedVariant();
 
   inline VARTYPE type() const {
     return var_.vt;
   }
 
   // Give ScopedVariant ownership over an already allocated VARIANT.
   void Reset(const VARIANT& var = kEmptyVariant);
 
   // Releases ownership of the VARIANT to the caller.
@@ skipping 23 matching lines @@
   void Set(int16 i16);
   void Set(uint16 ui16);
   void Set(int32 i32);
   void Set(uint32 ui32);
   void Set(int64 i64);
   void Set(uint64 ui64);
   void Set(float r32);
   void Set(double r64);
   void Set(bool b);
 
+  // Creates a copy of |var| and assigns as this instance's value.
+  // Note that this is different from the Reset() method that's used to
+  // free the current value and assume ownership.
+  void Set(const VARIANT& var);
+
   // COM object setters
   void Set(IDispatch* disp);
   void Set(IUnknown* unk);
 
   // SAFEARRAY support
   void Set(SAFEARRAY* array);
 
   // Special setter for DATE since DATE is a double and we already have
   // a setter for double.
   void SetDate(DATE date);
 
   // Allows const access to the contained variant without DCHECKs etc.
   // This support is necessary for the V_XYZ (e.g. V_BSTR) set of macros to
   // work properly but still doesn't allow modifications since we want control
   // over that.
   const VARIANT* operator&() const {
     return &var_;
   }
 
+  // Like other scoped classes (e.g scoped_refptr, ScopedComPtr, ScopedBstr)
+  // we support the assignment operator for the type we wrap.
+  ScopedVariant& operator=(const VARIANT& var);
+
   // A hack to pass a pointer to the variant where the accepting
   // function treats the variant as an input-only, read-only value
   // but the function prototype requires a non const variant pointer.
   // There's no DCHECK or anything here.  Callers must know what they're doing.
   VARIANT* AsInput() const {
     // The nature of this function is const, so we declare
     // it as such and cast away the constness here.
     return const_cast<VARIANT*>(&var_);
   }
 
@@ skipping 11 matching lines @@
 
  private:
   // Comparison operators for ScopedVariant are not supported at this point.
   // Use the Compare method instead.
   bool operator==(const ScopedVariant& var) const;
   bool operator!=(const ScopedVariant& var) const;
   DISALLOW_COPY_AND_ASSIGN(ScopedVariant);
 };
 
 #endif  // BASE_SCOPED_VARIANT_WIN_H_