Cleanup converting safe-browsing chunks to range list.

chrome/browser/safe_browsing/chunk_range.cc

 // 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.
 //
 // Implementation of ChunkRange class.
 
 #include "chrome/browser/safe_browsing/chunk_range.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 
 ChunkRange::ChunkRange(int start) : start_(start), stop_(start) {
 }
 
 ChunkRange::ChunkRange(int start, int stop) : start_(start), stop_(stop) {
 }
 
 ChunkRange::ChunkRange(const ChunkRange& rhs)
     : start_(rhs.start()), stop_(rhs.stop()) {
 }
 
 // Helper functions -----------------------------------------------------------
 
-// Traverse the chunks vector looking for contiguous integers.
-void ChunksToRanges(const std::vector<int>& chunks,
-                    std::vector<ChunkRange>* ranges) {
-  DCHECK(ranges);
-  for (size_t i = 0; i < chunks.size(); ++i) {
-    int start = static_cast<int>(i);
-    int next = start + 1;
-    while (next < static_cast<int>(chunks.size()) &&
-           (chunks[start] == chunks[next] - 1 ||
-            chunks[start] == chunks[next])) {
-      ++start;
-      ++next;
+void ChunksToRangeString(const std::vector<int>& chunks, std::string* result) {
+  // The following code requires the range to be sorted.
+  std::vector<int> sorted_chunks(chunks);
+  std::sort(sorted_chunks.begin(), sorted_chunks.end());
+
+  DCHECK(result);
+  result->clear();
+  std::vector<int>::const_iterator iter = sorted_chunks.begin();
+  while (iter != sorted_chunks.end()) {
+    const int range_begin = *iter;
+    int range_end = *iter;
+
+    // Extend the range forward across duplicates and increments.
+    for (; iter != sorted_chunks.end() && *iter <= range_end + 1; ++iter) {
+      range_end = *iter;
     }
-    ranges->push_back(ChunkRange(chunks[i], chunks[start]));
-    if (next >= static_cast<int>(chunks.size()))
-      break;
-    i = start;
+
+    if (!result->empty())
+      result->append(",");
+    result->append(base::IntToString(range_begin));
+    if (range_end > range_begin) {
+      result->append("-");
+      result->append(base::IntToString(range_end));
+    }
   }
 }
 
 void RangesToChunks(const std::vector<ChunkRange>& ranges,
                     std::vector<int>* chunks) {
   DCHECK(chunks);
   for (size_t i = 0; i < ranges.size(); ++i) {
     const ChunkRange& range = ranges[i];
     for (int chunk = range.start(); chunk <= range.stop(); ++chunk) {
       chunks->push_back(chunk);
     }
   }
 }
 
-void RangesToString(const std::vector<ChunkRange>& ranges,
-                    std::string* result) {
-  DCHECK(result);
-  result->clear();
-  std::vector<ChunkRange>::const_iterator it = ranges.begin();
-  for (; it != ranges.end(); ++it) {
-    if (!result->empty())
-      result->append(",");
-    if (it->start() == it->stop()) {
-      std::string num_buf = base::IntToString(it->start());
-      result->append(num_buf);
-    } else {
-      result->append(StringPrintf("%d-%d", it->start(), it->stop()));
-    }
-  }
-}
-
 bool StringToRanges(const std::string& input,
                     std::vector<ChunkRange>* ranges) {
   DCHECK(ranges);
 
   // Crack the string into chunk parts, then crack each part looking for a
   // range.
   std::vector<std::string> chunk_parts;
   base::SplitString(input, ',', &chunk_parts);
 
   for (size_t i = 0; i < chunk_parts.size(); ++i) {
@@ skipping 31 matching lines @@
 
     // Adjust our mid point.
     if (chunk.stop() < chunk_number)
       low = mid + 1;
     else
       high = mid - 1;
   }
 
   return false;
 }