Last small bit of refactoring.

courgette/ensemble.h

 // 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 115 matching lines @@
   //    stream 3:
   //      correction:
   //        base-file
   //        element-1
   //        element-2
   //        ...
 
   static const uint32 kMagic = 'C' | ('o' << 8) | ('u' << 16);
 
   static const uint32 kVersion = 20110216;
-
-  // Transformation method IDs. These are embedded in generated files, so
-  // never remove or change an existing id.
-  enum TransformationMethodId {
-    T_COURGETTE_WIN32_X86 = 1,  // Windows 32 bit 'Portable Executable' x86.
-  };
 };
 
 // For any transform you would implement both a TransformationPatcher and a
 // TransformationPatchGenerator.
 //
 // TransformationPatcher is the interface which abstracts out the actual
 // transformation used on an Element.  The patching itself happens outside the
 // actions of a TransformationPatcher.  There are four steps.
 //
 // The first step is an Init step.  The parameters to the Init step identify the
@@ skipping 49 matching lines @@
 //
 class TransformationPatchGenerator {
  public:
   TransformationPatchGenerator(Element* old_element,
                                Element* new_element,
                                TransformationPatcher* patcher);
 
   virtual ~TransformationPatchGenerator();
 
   // Returns the TransformationMethodId that identies this transformation.
-  virtual CourgettePatchFile::TransformationMethodId Kind() = 0;
+  virtual ExecutableType Kind() = 0;
 
   // Writes the parameters that will be passed to TransformationPatcher::Init.
   virtual Status WriteInitialParameters(SinkStream* parameter_stream) = 0;
 
   // Predicts the transform parameters for the |old_element|.  This must match
   // exactly the output that will be produced by the PredictTransformParameters
   // method of the corresponding subclass of TransformationPatcher.  This method
   // is not pure. The default implementation delegates to the patcher to
   // guarantee matching output.
   virtual Status PredictTransformParameters(SinkStreamSet* prediction);
@@ skipping 23 matching lines @@
                         SinkStream* reformed_element);
 
  protected:
   Element* old_element_;
   Element* new_element_;
   TransformationPatcher* patcher_;
 };
 
 }  // namespace
 #endif  // COURGETTE_ENSEMBLE_H_