Start refactoring to reduce executable type knowledge.

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 47 matching lines @@
 Status TransformationPatchGenerator::Reform(
     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) {
-  if (new_element->kind() == Element::WIN32_X86_WITH_CODE) {
-    CourgetteWin32X86PatchGenerator* generator =
-        new CourgetteWin32X86PatchGenerator(
-            old_element,
-            new_element,
-            new CourgetteWin32X86Patcher(old_element->region()));
-    return generator;
-  } else {
-    LOG(WARNING) << "Unexpected Element::Kind " << old_element->kind();
-    return NULL;
+  switch (new_element->kind()) {
+    case UNKNOWN:
+      LOG(WARNING) << "Unexpected Element::Kind " << old_element->kind();
+      return NULL;
+    case WIN32_X86: {
+      TransformationPatchGenerator* generator =
+          new CourgetteWin32X86PatchGenerator(
+              old_element,
+              new_element,
+              new CourgetteWin32X86Patcher(old_element->region()));
+      return generator;
+    }
   }
 }
 
 // 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'.
 // Each time this happens, the old element is transformed and serialized.  This
 // is a problem when the old element is huge compared with the new element
 // because the mutliple serialized copies can be much bigger than the size of
 // either ensemble.
 //
@@ skipping 327 matching lines @@
     return C_STREAM_ERROR;
   }
 
   VLOG(1) << "done GenerateEnsemblePatch "
           << (base::Time::Now() - start_time).InSecondsF() << "s";
 
   return C_OK;
 }
 
 }  // namespace