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

courgette/courgette_tool.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 262 matching lines @@
     courgette::SinkStream* old_stream = model_sinks.stream(i);
     courgette::SinkStream* new_stream = program_sinks.stream(i);
     if (old_stream == NULL && new_stream == NULL)
       break;
 
     courgette::SourceStream old_source;
     courgette::SourceStream new_source;
     old_source.Init(old_stream ? *old_stream : empty_sink);
     new_source.Init(new_stream ? *new_stream : empty_sink);
     courgette::SinkStream patch_stream;
-    courgette::BSDiffStatus status =
-        courgette::CreateBinaryPatch(&old_source, &new_source, &patch_stream);
-    if (status != courgette::OK) Problem("-xxx failed.");
+    bsdiff::BSDiffStatus status =
+        bsdiff::CreateBinaryPatch(&old_source, &new_source, &patch_stream);
+    if (status != bsdiff::OK) Problem("-xxx failed.");
 
     std::string append = std::string("-") + base::IntToString(i);
 
     WriteSinkToFile(&patch_stream,
                     output_file_root.InsertBeforeExtensionASCII(append));
   }
 }
 
 void Assemble(const base::FilePath& input_file,
               const base::FilePath& output_file) {
@@ skipping 101 matching lines @@
                          const base::FilePath& patch_file) {
   std::string old_buffer = ReadOrFail(old_file, "'old' input");
   std::string new_buffer = ReadOrFail(new_file, "'new' input");
 
   courgette::SourceStream old_stream;
   courgette::SourceStream new_stream;
   old_stream.Init(old_buffer);
   new_stream.Init(new_buffer);
 
   courgette::SinkStream patch_stream;
-  courgette::BSDiffStatus status =
-      courgette::CreateBinaryPatch(&old_stream, &new_stream, &patch_stream);
+  bsdiff::BSDiffStatus status =
+      bsdiff::CreateBinaryPatch(&old_stream, &new_stream, &patch_stream);
 
-  if (status != courgette::OK) Problem("-genbsdiff failed.");
+  if (status != bsdiff::OK) Problem("-genbsdiff failed.");
 
   WriteSinkToFile(&patch_stream, patch_file);
 }
 
 void ApplyBSDiffPatch(const base::FilePath& old_file,
                       const base::FilePath& patch_file,
                       const base::FilePath& new_file) {
   std::string old_buffer = ReadOrFail(old_file, "'old' input");
   std::string patch_buffer = ReadOrFail(patch_file, "'patch' input");
 
   courgette::SourceStream old_stream;
   courgette::SourceStream patch_stream;
   old_stream.Init(old_buffer);
   patch_stream.Init(patch_buffer);
 
   courgette::SinkStream new_stream;
-  courgette::BSDiffStatus status =
-      courgette::ApplyBinaryPatch(&old_stream, &patch_stream, &new_stream);
+  bsdiff::BSDiffStatus status =
+      bsdiff::ApplyBinaryPatch(&old_stream, &patch_stream, &new_stream);
 
-  if (status != courgette::OK) Problem("-applybsdiff failed.");
+  if (status != bsdiff::OK) Problem("-applybsdiff failed.");
 
   WriteSinkToFile(&new_stream, new_file);
 }
 
 int main(int argc, const char* argv[]) {
   base::AtExitManager at_exit_manager;
   base::CommandLine::Init(argc, argv);
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
@@ skipping 75 matching lines @@
         UsageProblem("-gen1[au] <old_file> <new_file> <patch_files_root>");
       DisassembleAdjustDiff(values[0], values[1], values[2],
                             cmd_spread_1_adjusted);
     } else {
       UsageProblem("No operation specified");
     }
   }
 
   return 0;
 }