Start refactoring to reduce executable type knowledge.

This creates executable detection functions, a globally shared enum for
describing an executable type, and reduces the number of classes and
locations with executable specific knowledge.

These changes, along with moving architecture specific classes into their
own files should make it easier to produce special purpose clients that
only contain the code required to apply their own form of patch.

DisassemblerWin32EXE, ImagePE, CourgetteWin32X86PatchGenerator, and
CourgetteWin32X86Patcher, and ensemble handling are all heavily affected here.

This should have no effect on the behavior of the system yet, and is instead
all prep-work.

This is the same as an earlier CL, except that ParseHeader will now return
an error for 64 bit PE executables, and resource only DLLs. This is because
the detection factories depend on ParseHeader to decide if a given file
is supported.

BUG=None
TEST=Unittests

Review URL: http://codereview.chromium.org/7920004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@103879 0039d316-1c4b-4281-b951-d872f2087c98


Review URL: http://codereview.chromium.org/8344037

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@106793 0039d316-1c4b-4281-b951-d872f2087c98

courgette/base_test_unittest.cc

@@ -7,7 +7,7 @@
 #include "base/path_service.h"
 
 void BaseTest::SetUp() {
-  PathService::Get(base::DIR_SOURCE_ROOT, &test_dir_);
+  ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_dir_));
   test_dir_ = test_dir_.AppendASCII("courgette");
   test_dir_ = test_dir_.AppendASCII("testdata");
 }

courgette/base_test_unittest.h

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <string>
-
 #ifndef COURGETTE_BASE_TEST_UNITTEST_H_
 #define COURGETTE_BASE_TEST_UNITTEST_H_
 
@@ -28,4 +26,4 @@ class BaseTest : public testing::Test {
   FilePath test_dir_;
 };
 
-#endif // COURGETTE_BASE_TEST_UNITTEST_H_
+#endif  // COURGETTE_BASE_TEST_UNITTEST_H_

courgette/courgette.gyp

@@ -22,6 +22,8 @@
       'difference_estimator.h',
       'disassembler.cc',
       'disassembler.h',
+      'disassembler_win32_x86.cc',
+      'disassembler_win32_x86.h',
       'encoded_program.cc',
       'encoded_program.h',
       'ensemble.cc',

courgette/courgette.h

@@ -1,4 +1,4 @@
-// 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.
 
@@ -50,6 +50,13 @@ enum Status {
   C_ADJUSTMENT_FAILED = 27,       //
 };
 
+// What type of executable is something
+// Generally corresponds to CourgettePatchFile::TransformationMethodId
+enum ExecutableType {
+  UNKNOWN,
+  WIN32_X86
+};
+
 class SinkStream;
 class SinkStreamSet;
 class SourceStream;
@@ -80,12 +87,16 @@ Status ApplyEnsemblePatch(const FilePath::CharType* old_file_name,
 Status GenerateEnsemblePatch(SourceStream* old, SourceStream* target,
                              SinkStream* patch);
 
-// Parses a Windows 32-bit 'Portable Executable' format file from memory,
-// storing the pointer to the AssemblyProgram in |*output|.
+// Detects the type of an executable, and returns UNKNOWN if it cannot
+// be parsed.
+ExecutableType DetectExecutableType(const void* buffer, size_t length);
+
+// Attempts to detect the type of executable, and parse it with the
+// appropriate tools, storing the pointer to the AssemblyProgram in |*output|.
 // Returns C_OK if successful, otherwise returns an error status and sets
 // |*output| to NULL.
-Status ParseWin32X86PE(const void* buffer, size_t length,
-                       AssemblyProgram** output);
+Status ParseDetectedExecutable(const void* buffer, size_t length,
+                               AssemblyProgram** output);
 
 // Converts |program| into encoded form, returning it as |*output|.
 // Returns C_OK if succeeded, otherwise returns an error status and

courgette/courgette_tool.cc

@@ -85,7 +85,8 @@ void Disassemble(const std::wstring& input_file,
 
   courgette::AssemblyProgram* program = NULL;
   const courgette::Status parse_status =
-      courgette::ParseWin32X86PE(buffer.c_str(), buffer.length(), &program);
+      courgette::ParseDetectedExecutable(buffer.c_str(), buffer.length(),
+                                         &program);
 
   if (parse_status != courgette::C_OK)
     Problem("Can't parse input.");
@@ -122,17 +123,17 @@ void DisassembleAndAdjust(const std::wstring& program_file,
 
   courgette::AssemblyProgram* program = NULL;
   const courgette::Status parse_program_status =
-      courgette::ParseWin32X86PE(program_buffer.c_str(),
-                                 program_buffer.length(),
-                                 &program);
+      courgette::ParseDetectedExecutable(program_buffer.c_str(),
+                                         program_buffer.length(),
+                                         &program);
   if (parse_program_status != courgette::C_OK)
     Problem("Can't parse program input.");
 
   courgette::AssemblyProgram* model = NULL;
   const courgette::Status parse_model_status =
-      courgette::ParseWin32X86PE(model_buffer.c_str(),
-                                 model_buffer.length(),
-                                 &model);
+      courgette::ParseDetectedExecutable(model_buffer.c_str(),
+                                         model_buffer.length(),
+                                         &model);
   if (parse_model_status != courgette::C_OK)
     Problem("Can't parse model input.");
 
@@ -178,17 +179,17 @@ void DisassembleAdjustDiff(const std::wstring& model_file,
 
   courgette::AssemblyProgram* model = NULL;
   const courgette::Status parse_model_status =
-      courgette::ParseWin32X86PE(model_buffer.c_str(),
-                                 model_buffer.length(),
-                                 &model);
+      courgette::ParseDetectedExecutable(model_buffer.c_str(),
+                                         model_buffer.length(),
+                                         &model);
   if (parse_model_status != courgette::C_OK)
     Problem("Can't parse model input.");
 
   courgette::AssemblyProgram* program = NULL;
   const courgette::Status parse_program_status =
-      courgette::ParseWin32X86PE(program_buffer.c_str(),
-                                 program_buffer.length(),
-                                 &program);
+      courgette::ParseDetectedExecutable(program_buffer.c_str(),
+                                         program_buffer.length(),
+                                         &program);
   if (parse_program_status != courgette::C_OK)
     Problem("Can't parse program input.");