Improve support for multiselect list box accessibility on Windows.

base/win/enum_variant.cc

Index: base/win/enum_variant.cc
===================================================================
--- base/win/enum_variant.cc	(revision 0)
+++ base/win/enum_variant.cc	(revision 0)
@@ -0,0 +1,87 @@
+// Copyright (c) 2011 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.
+
+#include "base/logging.h"
+#include "base/win/enum_variant.h"
+
+namespace base {
+namespace win {
+
+EnumVariant::EnumVariant(unsigned long count)
+    : count_(count) {
+  items_.reset(new VARIANT[count_]);
+  current_index_ = 0;
+  iunknown_ref_count_ = 1;
+}
+
+EnumVariant::~EnumVariant() {
+}
+
+VARIANT* EnumVariant::get(unsigned long index) {
+  DCHECK(index < count_);
+  return &items_[index];
+}
+
+ULONG STDMETHODCALLTYPE EnumVariant::AddRef() {
+  return InterlockedIncrement(&iunknown_ref_count_);
+}
+
+ULONG STDMETHODCALLTYPE EnumVariant::Release() {
+  ULONG ref_count = InterlockedDecrement(&iunknown_ref_count_);
+  if (ref_count == 0)
+    delete this;
+  return ref_count;
+}
+
+STDMETHODIMP EnumVariant::QueryInterface(REFIID riid, void** ppv) {
+  if (riid == IID_IUnknown ||
+      riid == IID_IEnumVARIANT) {
+    *ppv = this;
+    AddRef();
+    return S_OK;
+  }
+
+  *ppv = NULL;
+  return E_NOINTERFACE;
+}
+
+STDMETHODIMP EnumVariant::Next(ULONG requested_count,
+                               VARIANT* out_elements,
+                               ULONG* out_elements_received) {
+  unsigned long count = requested_count;
+  if (current_index_ + count > count_)
+    count = count_ - current_index_;
+
+  for (unsigned long i = 0; i < count; ++i)
+    out_elements[i] = items_[current_index_ + i];
+  current_index_ += count;
+  *out_elements_received = count;
+
+  return (count == requested_count ? S_OK : S_FALSE);
+}
+
+STDMETHODIMP EnumVariant::Skip(ULONG skip_count) {
+  unsigned long count = skip_count;
+  if (current_index_ + count > count_)
+    count = count_ - current_index_;
+
+  current_index_ += count;
+  return (count == skip_count ? S_OK : S_FALSE);
+}
+
+STDMETHODIMP EnumVariant::Reset() {
+  current_index_ = 0;
+  return S_OK;
+}
+
+STDMETHODIMP EnumVariant::Clone(IEnumVARIANT** out_cloned_object) {
+  EnumVariant* other = new EnumVariant(count_);
+  for (unsigned long i = 0; i < count_; ++i)
+    *other->get(i) = items_[i];

[darin (slow to review), 2011/11/22 01:16:52]

it is interesting that there is no memory management required here.  this code
is creating multiple references to the same VARIANT.  if the lifetime of the
resulting clone is longer than the object being cloned, then isn't there the
potential for the VARIANT items to reference deleted memory?  i'm assuming that
it is possible for the VARIANTs to reference heap allocated memory.  although, i
don't see any special cleanup happening in ~EnumVariant.

is there some restriction on the type of VARIANTs that should be used with
EnumVariant?

[dmazzoni, 2011/11/22 08:08:14]

Good question.

A VARIANT isn't an object, it's data. It might contain a pointer, yes - but the
fact that the pointer is contained inside a VARIANT has no impact on its
reference count or ownership semantics. The VARIANT itself does not "own" a
reference to an object that it points to, if it contains a pointer.

Suppose you're a client and you call a COM method that returns an array of
results in an IEnumVARIANT. If any of those items are of type VT_DISPATCH, then
the method has just given you a new reference to that result, and it's now your
responsibility to Release it, just as if that same method had returned a single
VARIANT.

+  *out_cloned_object = other;
+  return S_OK;
+}
+
+}  // namespace win
+}  // namespace base