Start refactoring to reduce executable type knowledge.

courgette/ensemble.h

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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,
 // but there may be many different kinds of elements, which have different
@@ skipping 17 matching lines @@
 namespace courgette {
 
 // Forward declarations:
 class Ensemble;
 class PEInfo;
 
 // An Element is a region of an Ensemble with an identifyable kind.
 //
 class Element {
  public:
-  enum Kind { WIN32_X86_WITH_CODE, WIN32_NOCODE };
+  Element(ExecutableType kind,
+          Ensemble* ensemble,
+          const Region& region,
+          PEInfo*info);
 
-  virtual ~Element() {}
+  virtual ~Element();
 
-  Kind kind() const { return kind_; }
+  ExecutableType kind() const { return kind_; }
   const Region& region() const { return region_; }
 
   // The name is used only for debugging and logging.
   virtual std::string Name() const;
 
   // Returns the byte position of this Element relative to the start of
   // containing Ensemble.
   size_t offset_in_ensemble() const;
 
-  // Some subclasses of Element might have a PEInfo.
-  virtual PEInfo* GetPEInfo() const { return NULL; }
-
- protected:
-  Element(Kind kind, Ensemble* ensemble, const Region& region);
+  // The ImageInfo for this executable
+  virtual PEInfo* GetImageInfo() const { return info_; }

[Michael Krebs, 2011/10/21 02:44:36]

You made the method name generic, while the return value is still PE-specific. 
Given the data is also PE-specific, I would think GetPEInfo() would be fine. 
...although this nit may be moot depending on what changes are made for ELF.

[dgarrett, 2011/10/21 18:24:59]

You are right, but this gets fixed in the next step of the refactor.

 
  private:
-  Kind kind_;
+  ExecutableType kind_;
   Ensemble* ensemble_;
   Region region_;
+  PEInfo *info_;
 
   DISALLOW_COPY_AND_ASSIGN(Element);
 };
 
 
 class Ensemble {
  public:
   Ensemble(const Region& region, const char* name)
       : region_(region), name_(name) {}
   ~Ensemble();
@@ skipping 59 matching lines @@
   //      correction:
   //        base-file
   //        element-1
   //        element-2
   //        ...
 
   static const uint32 kMagic = 'C' | ('o' << 8) | ('u' << 16);
 
   static const uint32 kVersion = 20110216;
 
-  // Transformation method IDs.
+  // 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
@@ skipping 96 matching lines @@
                         SinkStream* reformed_element);
 
  protected:
   Element* old_element_;
   Element* new_element_;
   TransformationPatcher* patcher_;
 };
 
 }  // namespace
 #endif  // COURGETTE_ENSEMBLE_H_