[Courgette] Refactor BSDiff namespaces and bsdiff::search() interface.

courgette/third_party/bsdiff/bsdiff_create.cc

 // Copyright 2003, 2004 Colin Percival
 // All rights reserved
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted providing that the following conditions
 // are met:
 // 1. Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
 // 2. Redistributions in binary form must reproduce the above copyright
 //    notice, this list of conditions and the following disclaimer in the
@@ skipping 47 matching lines @@
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 
 #include "courgette/crc.h"
 #include "courgette/streams.h"
 #include "courgette/third_party/bsdiff/bsdiff_search.h"
 #include "courgette/third_party/bsdiff/paged_array.h"
 #include "courgette/third_party/bsdiff/qsufsort.h"
 
-namespace courgette {
+namespace {
+
+using courgette::CalculateCrc;
+using courgette::PagedArray;
+using courgette::SinkStream;
+using courgette::SinkStreamSet;
+using courgette::SourceStream;
+using courgette::SourceStreamSet;
+
+}  // namespace
+
+namespace bsdiff {
 
 static CheckBool WriteHeader(SinkStream* stream, MBSPatchHeader* header) {
   bool ok = stream->Write(header->tag, sizeof(header->tag));
   ok &= stream->WriteVarint32(header->slen);
   ok &= stream->WriteVarint32(header->scrc32);
   ok &= stream->WriteVarint32(header->dlen);
   return ok;
 }
 
 BSDiffStatus CreateBinaryPatch(SourceStream* old_stream,
@@ skipping 79 matching lines @@
   //    fffffffffffffff                 |lenf| = scan forward from |lastscan|
   //                     bbbb           |lenb| = scan back from new seed |scan|.
   //    ddddddddddddddd                 Emit diff bytes for the 'copy'.
   //                   xx               Emit extra bytes.
   //                     ssssssssssss   |lastscan = scan - lenb| is new seed.
   //                                 x  Cases (1) and (3) ....
 
   int lastscan = 0, lastpos = 0, lastoffset = 0;
 
   int scan = 0;
-  int match_length = 0;
+  SearchResult match(0, 0);
 
   while (scan < newsize) {
-    int pos = 0;
     int oldscore = 0;  // Count of how many bytes of the current match at |scan|
                        // extend the match at |lastscan|.
+    match.pos = 0;
 
-    scan += match_length;
+    scan += match.size;
     for (int scsc = scan; scan < newsize; ++scan) {
-      match_length = courgette::search<PagedArray<int>&>(
-          I, old, oldsize, newbuf + scan, newsize - scan, &pos);
+      match = search<PagedArray<int>&>(
+          I, old, oldsize, newbuf + scan, newsize - scan);
 
-      for (; scsc < scan + match_length; scsc++)
+      for (; scsc < scan + match.size; scsc++)
         if ((scsc + lastoffset < oldsize) &&
             (old[scsc + lastoffset] == newbuf[scsc]))
           oldscore++;
 
-      if ((match_length == oldscore) && (match_length != 0))
+      if ((match.size == oldscore) && (match.size != 0))
         break;  // Good continuing match, case (1)
-      if (match_length > oldscore + 8)
+      if (match.size > oldscore + 8)
         break;  // New seed match, case (2)
 
       if ((scan + lastoffset < oldsize) &&
           (old[scan + lastoffset] == newbuf[scan]))
         oldscore--;
       // Case (3) continues in this loop until we fall out of the loop (4).
     }
 
-    if ((match_length != oldscore) || (scan == newsize)) {  // Cases (2) and (4)
+    if ((match.size != oldscore) || (scan == newsize)) {  // Cases (2) and (4)
       // This next chunk of code finds the boundary between the bytes to be
       // copied as part of the current triple, and the bytes to be copied as
       // part of the next triple.  The |lastscan| match is extended forwards as
       // far as possible provided doing to does not add too many mistakes.  The
       // |scan| match is extended backwards in a similar way.
 
       // Extend the current match (if any) backwards.  |lenb| is the maximal
       // extension for which less than half the byte positions in the extension
       // are wrong.
       int lenb = 0;
       if (scan < newsize) {  // i.e. not case (4); there is a match to extend.
         int score = 0, Sb = 0;
-        for (int i = 1; (scan >= lastscan + i) && (pos >= i); i++) {
-          if (old[pos - i] == newbuf[scan - i])
+        for (int i = 1; (scan >= lastscan + i) && (match.pos >= i); i++) {
+          if (old[match.pos - i] == newbuf[scan - i])
             score++;
           if (score * 2 - i > Sb * 2 - lenb) {
             Sb = score;
             lenb = i;
           }
         }
       }
 
       // Extend the lastscan match forward; |lenf| is the maximal extension for
       // which less than half of the byte positions in entire lastscan match are
@@ skipping 19 matching lines @@
       // that maximizes the exact matching bytes.
       if (lastscan + lenf > scan - lenb) {
         int overlap = (lastscan + lenf) - (scan - lenb);
         int score = 0;
         int Ss = 0, lens = 0;
         for (int i = 0; i < overlap; i++) {
           if (newbuf[lastscan + lenf - overlap + i] ==
               old[lastpos + lenf - overlap + i]) {
             score++;
           }
-          if (newbuf[scan - lenb + i] == old[pos - lenb + i]) {
+          if (newbuf[scan - lenb + i] == old[match.pos - lenb + i]) {
             score--;
           }
           if (score > Ss) {
             Ss = score;
             lens = i + 1;
           }
         }
 
         lenf += lens - overlap;
         lenb -= lens;
@@ skipping 16 matching lines @@
       for (int i = 0; i < gap; i++) {
         if (!extra_bytes->Write(&newbuf[lastscan + lenf + i], 1))
           return MEM_ERROR;
       }
 
       diff_bytes_length += lenf;
       extra_bytes_length += gap;
 
       uint32_t copy_count = lenf;
       uint32_t extra_count = gap;
-      int32_t seek_adjustment = ((pos - lenb) - (lastpos + lenf));
+      int32_t seek_adjustment = ((match.pos - lenb) - (lastpos + lenf));
 
       if (!control_stream_copy_counts->WriteVarint32(copy_count) ||
           !control_stream_extra_counts->WriteVarint32(extra_count) ||
           !control_stream_seeks->WriteVarint32Signed(seek_adjustment)) {
         return MEM_ERROR;
       }
 
       ++control_length;
 #ifdef DEBUG_bsmedberg
       VLOG(1) << StringPrintf(
           "Writing a block:  copy: %-8u extra: %-8u seek: %+-9d", copy_count,
           extra_count, seek_adjustment);
 #endif
 
       lastscan = scan - lenb;  // Include the backward extension in seed.
-      lastpos = pos - lenb;    //  ditto.
+      lastpos = match.pos - lenb;    //  ditto.
       lastoffset = lastpos - lastscan;
     }
   }
 
   if (!diff_skips->WriteVarint32(pending_diff_zeros))
     return MEM_ERROR;
 
   I.clear();
 
   MBSPatchHeader header;
@@ skipping 18 matching lines @@
           << "  (skips: " << diff_skips_length << ")"
           << "  extra bytes: " << extra_bytes_length
           << "\nUncompressed bsdiff patch size "
           << patch_stream->Length() - initial_patch_stream_length
           << "\nEnd bsdiff "
           << (base::Time::Now() - start_bsdiff_time).InSecondsF();
 
   return OK;
 }
 
-}  // namespace courgette
+}  // namespace bsdiff