Omnibox: Highlight Matches in URLs Properly

base/strings/utf_offset_string_conversions.cc

 // 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/strings/utf_offset_string_conversions.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 19 matching lines @@
   for (std::vector<size_t>::iterator i(offsets_for_adjustment->begin());
        i != offsets_for_adjustment->end(); ++i)
     AdjustOffset(adjustments, &(*i));
 }
 
 // static
 void OffsetAdjuster::AdjustOffset(const Adjustments& adjustments,
                                   size_t* offset) {
   if (*offset == string16::npos)
     return;
-  size_t adjustment = 0;
+  int adjustment = 0;

[willchan no longer on Chromium, 2014/04/25 00:07:20]

QQ: Why did this switch to int? Also, is it impossible to overflow? I don't see
any overflow checks.

[Mark P, 2014/04/25 02:29:02]

Although it doesn't generally happen, it in theory could go negative.  Or at
least this function might as well support adjustments in which it could go
negative (i.e., that extend the length of a string).    In other words, int is
more correct.
All the strings and adjustments involved here are on the order of 1-1000kb.  So,
no, it shouldn't overflow.  Indeed, the only way it could overflow is if we have
an original string longer than 2^32 characters long...  This is not something
I'm concerned about.

[willchan no longer on Chromium, 2014/04/25 05:24:43]

Great.
OK, I just saw a security bug earlier that missed this check so I am a bit more
sensitive to this now :) If you guys are confident about this, I'm fine with it.

   for (Adjustments::const_iterator i = adjustments.begin();
        i != adjustments.end(); ++i) {
     if (*offset <= i->original_offset)
       break;
     if (*offset < (i->original_offset + i->original_length)) {
       *offset = string16::npos;
       return;
     }
     adjustment += (i->original_length - i->output_length);
   }
   *offset -= adjustment;
 }
 
 // static
+void OffsetAdjuster::UnadjustOffsets(
+    const Adjustments& adjustments,
+    std::vector<size_t>* offsets_for_unadjustment) {
+  if (!offsets_for_unadjustment || adjustments.empty())
+    return;
+  for (std::vector<size_t>::iterator i(offsets_for_unadjustment->begin());
+       i != offsets_for_unadjustment->end(); ++i)
+    UnadjustOffset(adjustments, &(*i));
+}
+
+// static
+void OffsetAdjuster::UnadjustOffset(const Adjustments& adjustments,
+                                    size_t* offset) {
+  if (*offset == string16::npos)
+    return;
+  int adjustment = 0;
+  for (Adjustments::const_iterator i = adjustments.begin();
+       i != adjustments.end(); ++i) {
+    if (*offset + adjustment <= i->original_offset)
+      break;
+    adjustment += (i->original_length - i->output_length);
+    if ((*offset + adjustment) <
+        (i->original_offset + i->original_length)) {
+      *offset = string16::npos;
+      return;
+    }
+  }
+  *offset += adjustment;
+}
+
+// static
 void OffsetAdjuster::MergeSequentialAdjustments(
     const Adjustments& first_adjustments,
     Adjustments* adjustments_on_adjusted_string) {
   Adjustments::iterator adjusted_iter = adjustments_on_adjusted_string->begin();
   Adjustments::const_iterator first_iter = first_adjustments.begin();
   // Simultaneously iterate over all |adjustments_on_adjusted_string| and
   // |first_adjustments|, adding adjustments to or correcting the adjustments
   // in |adjustments_on_adjusted_string| as we go.  |shift| keeps track of the
   // current number of characters collapsed by |first_adjustments| up to this
   // point.  |currently_collapsing| keeps track of the number of characters
@@ skipping 155 matching lines @@
                 LimitOffset<base::StringPiece16>(utf16.length()));
   std::string result;
   PrepareForUTF8Output(utf16.data(), utf16.length(), &result);
   OffsetAdjuster::Adjustments adjustments;
   ConvertUnicode(utf16.data(), utf16.length(), &result, &adjustments);
   OffsetAdjuster::AdjustOffsets(adjustments, offsets_for_adjustment);
   return result;
 }
 
 }  // namespace base