Unsigned warning fix - take 2

app/os_exchange_data_provider_win.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 "app/os_exchange_data_provider_win.h"
 
 #include "app/clipboard/clipboard_util_win.h"
 #include "app/l10n_util.h"
 #include "base/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/logging.h"
@@ skipping 65 matching lines @@
   static FormatEtcEnumerator* CloneFromOther(const FormatEtcEnumerator* other);
 
  private:
   // We are _forced_ to use a vector as our internal data model as Windows'
   // retarded IEnumFORMATETC API assumes a deterministic ordering of elements
   // through methods like Next and Skip. This exposes the underlying data
   // structure to the user. Bah.
   std::vector<FORMATETC*> contents_;
 
   // The cursor of the active enumeration - an index into |contents_|.
-  int cursor_;
+  size_t cursor_;
 
   LONG ref_count_;
 
   DISALLOW_EVIL_CONSTRUCTORS(FormatEtcEnumerator);
 };
 
 // Safely makes a copy of all of the relevant bits of a FORMATETC object.
 static void CloneFormatEtc(FORMATETC* source, FORMATETC* clone) {
   *clone = *source;
   if (source->ptd) {
@@ skipping 20 matching lines @@
   STLDeleteContainerPointers(contents_.begin(), contents_.end());
 }
 
 STDMETHODIMP FormatEtcEnumerator::Next(
     ULONG count, FORMATETC* elements_array, ULONG* elements_fetched) {
   // MSDN says |elements_fetched| is allowed to be NULL if count is 1.
   if (!elements_fetched)
     DCHECK(count == 1);
 
   // This method copies count elements into |elements_array|.
-  int index = 0;
-  while (cursor_ < static_cast<int>(contents_.size()) &&
-         static_cast<ULONG>(index) < count) {
+  ULONG index = 0;
+  while (cursor_ < contents_.size() && index < count) {
     CloneFormatEtc(contents_.at(cursor_), &elements_array[index]);
     ++cursor_;
     ++index;
   }
   // The out param is for how many we actually copied.
   if (elements_fetched)
     *elements_fetched = index;
 
   // If the two don't agree, then we fail.
   return index == count ? S_OK : S_FALSE;
 }
 
 STDMETHODIMP FormatEtcEnumerator::Skip(ULONG skip_count) {
   cursor_ += skip_count;
   // MSDN implies it's OK to leave the enumerator trashed.
   // "Whatever you say, boss"
-  return cursor_ <= static_cast<int>(contents_.size()) ? S_OK : S_FALSE;
+  return cursor_ <= contents_.size() ? S_OK : S_FALSE;
 }
 
 STDMETHODIMP FormatEtcEnumerator::Reset() {
   cursor_ = 0;
   return S_OK;
 }
 
 STDMETHODIMP FormatEtcEnumerator::Clone(IEnumFORMATETC** clone) {
   // Clone the current enumerator in its exact state, including cursor.
   FormatEtcEnumerator* e = CloneFromOther(this);
@@ skipping 753 matching lines @@
 // static
 OSExchangeData::Provider* OSExchangeData::CreateProvider() {
   return new OSExchangeDataProviderWin();
 }
 
 // static
 OSExchangeData::CustomFormat OSExchangeData::RegisterCustomFormat(
     const std::string& type) {
   return RegisterClipboardFormat(ASCIIToWide(type).c_str());
 }