Last small bit of refactoring.

courgette/ensemble_create.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.
 
 // The main idea in Courgette is to do patching *under a tranformation*.  The
 // input is transformed into a new representation, patching occurs in the new
 // repesentation, and then the tranform is reversed to get the patched data.
 //
 // The idea is applied to pieces (or 'elements') of the whole (or 'ensemble').
 // Each of the elements has to go through the same set of steps in lock-step.
@@ skipping 10 matching lines @@
 #include "base/logging.h"
 #include "base/time.h"
 
 #include "courgette/third_party/bsdiff.h"
 #include "courgette/crc.h"
 #include "courgette/difference_estimator.h"
 #include "courgette/streams.h"
 #include "courgette/region.h"
 #include "courgette/simple_delta.h"
 
-#include "courgette/win32_x86_patcher.h"
-#include "courgette/win32_x86_generator.h"
+#include "courgette/patcher_x86_32.h"
+#include "courgette/patch_generator_x86_32.h"
 
 namespace courgette {
 
 TransformationPatchGenerator::TransformationPatchGenerator(
     Element* old_element,
     Element* new_element,
     TransformationPatcher* patcher)
     : old_element_(old_element),
       new_element_(new_element),
       patcher_(patcher) {
@@ skipping 15 matching lines @@
     SourceStreamSet* transformed_element,
     SinkStream* reformed_element) {
   return patcher_->Reform(transformed_element, reformed_element);
 }
 
 // Makes a TransformationPatchGenerator of the appropriate variety for the
 // Element kind.
 TransformationPatchGenerator* MakeGenerator(Element* old_element,
                                             Element* new_element) {
   switch (new_element->kind()) {
-    case UNKNOWN:
+    case EXE_UNKNOWN:
       break;
-    case WIN32_X86: {
+    case EXE_WIN_32_X86: {
       TransformationPatchGenerator* generator =
-          new CourgetteWin32X86PatchGenerator(
+          new PatchGeneratorX86_32(
               old_element,
               new_element,
-              new CourgetteWin32X86Patcher(old_element->region()));
+              new PatcherX86_32(old_element->region()),
+              EXE_WIN_32_X86);
       return generator;
     }
   }
 
   LOG(WARNING) << "Unexpected Element::Kind " << old_element->kind();
   return NULL;
 }
 
 // Checks to see if the proposed comparison is 'unsafe'.  Sometimes one element
 // from 'old' is matched as the closest element to multiple elements from 'new'.
@@ skipping 147 matching lines @@
   SinkStream* tranformation_descriptions      = patch_streams.stream(0);
   SinkStream* parameter_correction            = patch_streams.stream(1);
   SinkStream* transformed_elements_correction = patch_streams.stream(2);
   SinkStream* ensemble_correction             = patch_streams.stream(3);
 
   size_t number_of_transformations = generators.size();
   if (!tranformation_descriptions->WriteSizeVarint32(number_of_transformations))
     return C_STREAM_ERROR;
 
   for (size_t i = 0;  i < number_of_transformations;  ++i) {
-    CourgettePatchFile::TransformationMethodId kind = generators[i]->Kind();
+    ExecutableType kind = generators[i]->Kind();
     if (!tranformation_descriptions->WriteVarint32(kind))
       return C_STREAM_ERROR;
   }
 
   for (size_t i = 0;  i < number_of_transformations;  ++i) {
     Status status =
         generators[i]->WriteInitialParameters(tranformation_descriptions);
     if (status != C_OK)
       return status;
   }
@@ skipping 164 matching lines @@
     return C_STREAM_ERROR;
   }
 
   VLOG(1) << "done GenerateEnsemblePatch "
           << (base::Time::Now() - start_time).InSecondsF() << "s";
 
   return C_OK;
 }
 
 }  // namespace