Move Courgette

   from src\third_party\courgette
   to   src\courgette and src\courgette\third_party

Fixed #includes

Added properties to ignore generated files:

C:\c5\src>svn pg svn:ignore courgette
courgette.xcodeproj
courgette.sln
courgette_fuzz.vcproj
courgette_lib.vcproj
courgette_minimal_tool.vcproj
courgette_tool.vcproj
courgette.vcproj
courgette_unittests.vcproj
SConstruct
courgette_fuzz.scons
courgette_lib.scons
courgette_main.scons
courgette_minimal_tool.scons
courgette.scons
courgette_tool.scons
courgette_unittests.scons


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

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

50 files changed, 4834 insertions, 4724 deletions

diff --git a/build/all.gyp b/build/all.gyp
index a2ef584..f2c85a8 100644
--- a/build/all.gyp
+++ b/build/all.gyp
@@ -59,7 +59,7 @@
         ['OS=="win"', {
           'dependencies': [
             '../sandbox/sandbox.gyp:*',
-            '../third_party/courgette/courgette.gyp:*',
+            '../courgette/courgette.gyp:*',
             '../webkit/activex_shim/activex_shim.gyp:*',
             '../webkit/activex_shim_dll/activex_shim_dll.gyp:*',
             'temp_gyp/breakpad.gyp:*',
diff --git a/chrome/chrome.sln b/chrome/chrome.sln
index 4be747b..ce4d621 100644
--- a/chrome/chrome.sln
+++ b/chrome/chrome.sln
@@ -1487,9 +1487,9 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tcmalloc", "..\third_party\
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "app", "..\app\app.vcproj", "{4631946D-7D5F-44BD-A5A8-504C0A7033BE}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_lib", "..\third_party\courgette\courgette_lib.vcproj", "{9A72A362-E617-4205-B9F2-43C6FB280FA1}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_lib", "..\courgette\courgette_lib.vcproj", "{9A72A362-E617-4205-B9F2-43C6FB280FA1}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_fuzz", "..\third_party\courgette\courgette_fuzz.vcproj", "{57C27529-8CA9-4FC3-9C02-DA05B172F785}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_fuzz", "..\courgette\courgette_fuzz.vcproj", "{57C27529-8CA9-4FC3-9C02-DA05B172F785}"
 	ProjectSection(ProjectDependencies) = postProject
 		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}
 		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}
@@ -1498,7 +1498,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_fuzz", "..\third_
 		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {F22022F0-2D3B-5610-4E80-C674A8E01C5A}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_unittests", "..\third_party\courgette\courgette_unittests.vcproj", "{24309F1A-4035-46F9-A3D8-F47DC4BCC2B8}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_unittests", "..\courgette\courgette_unittests.vcproj", "{24309F1A-4035-46F9-A3D8-F47DC4BCC2B8}"
 	ProjectSection(ProjectDependencies) = postProject
 		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}
 		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}
@@ -1507,7 +1507,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_unittests", "..\t
 		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {F22022F0-2D3B-5610-4E80-C674A8E01C5A}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_tool", "..\third_party\courgette\courgette_tool.vcproj", "{4EA8CE12-9C6F-45E5-9D08-720383FE3685}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette", "..\courgette\courgette.vcproj", "{4EA8CE12-9C6F-45E5-9D08-720383FE3685}"
 	ProjectSection(ProjectDependencies) = postProject
 		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}
 		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}
@@ -1515,7 +1515,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_tool", "..\third_
 		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {F22022F0-2D3B-5610-4E80-C674A8E01C5A}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_minimal_tool", "..\third_party\courgette\courgette_minimal_tool.vcproj", "{EB79415F-2F17-4BDC-AADD-4CA4C2D21B73}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_minimal_tool", "..\courgette\courgette_minimal_tool.vcproj", "{EB79415F-2F17-4BDC-AADD-4CA4C2D21B73}"
 	ProjectSection(ProjectDependencies) = postProject
 		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}
 		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}
diff --git a/third_party/courgette/adjustment_method.cc b/courgette/adjustment_method.cc
index 8f6caef..48e7cc0 100644
--- a/third_party/courgette/adjustment_method.cc
+++ b/courgette/adjustment_method.cc
@@ -1,703 +1,703 @@
-// Copyright (c) 2009 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.

-

-#include "third_party/courgette/adjustment_method.h"

-

-#include <algorithm>

-#include <list>

-#include <map>

-#include <set>

-#include <string>

-#include <vector>

-

-#include "base/basictypes.h"

-#include "base/logging.h"

-#include "base/string_util.h"

-

-#include "third_party/courgette/assembly_program.h"

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/encoded_program.h"

-#include "third_party/courgette/image_info.h"

-

-namespace courgette {

-

-// We have three discretionary information logging levels for algorithm

-// development.  For now just configure with #defines.

-// TODO(sra): make dependent of some configurable setting.

-#define NO_LOG DLOG_IF(INFO, false)

-// #define ALOG1 LOG(INFO)

-// #define ALOG2 LOG(INFO)

-// #define ALOG3 LOG(INFO)

-#define ALOG1 NO_LOG

-#define ALOG2 NO_LOG

-#define ALOG3 NO_LOG

-

-////////////////////////////////////////////////////////////////////////////////

-

-class NullAdjustmentMethod : public AdjustmentMethod {

-  bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {

-    return true;

-  }

-};

-

-////////////////////////////////////////////////////////////////////////////////

-

-// The purpose of adjustment is to assign indexes to Labels of a program 'p' to

-// make the sequence of indexes similar to a 'model' program 'm'.  Labels

-// themselves don't have enough information to do this job, so we work with a

-// LabelInfo surrogate for each label.

-//

-class LabelInfo {

- public:

-  Label* label_;              // The label that this info a surrogate for.

-

-  // Information used only in debugging messages.

-  uint32 is_model_ : 1;       // Is the label in the model?

-  uint32 debug_index_ : 31;   // An unique small number for naming the label.

-

-  uint32 refs_;               // Number of times this Label is referenced.

-

-  LabelInfo* assignment_;     // Label from other program corresponding to this.

-

-  // LabelInfos are in a doubly linked list ordered by address (label_->rva_) so

-  // we can quickly find Labels adjacent in address order.

-  LabelInfo* next_addr_;      // Label(Info) at next highest address.

-  LabelInfo* prev_addr_;      // Label(Info) at next lowest address.

-

-  std::vector<uint32> positions_;  // Offsets into the trace of references.

-

-  // Just a no-argument constructor and copy constructor.  Actual LabelInfo

-  // objects are allocated in std::pair structs in a std::map.

-  LabelInfo()

-      : label_(NULL), is_model_(false), debug_index_(0), refs_(0),

-        assignment_(NULL),

-        next_addr_(NULL),

-        prev_addr_(NULL) {}

-

- private:

-  void operator=(const LabelInfo*);  // Disallow assignment only.

-

-  // Public compiler generated copy constructor is needed to constuct

-  // std::pair<Label*, LabelInfo> so that fresh LabelInfos can be allocated

-  // inside a std::map.

-};

-

-struct OrderLabelInfoByAddressAscending {

-  bool operator()(const LabelInfo* a, const LabelInfo* b) const {

-    return a->label_->rva_ < b->label_->rva_;

-  }

-};

-

-static std::string ToString(LabelInfo* info) {

-  std::string s;

-  StringAppendF(&s, "%c%d", "pm"[info->is_model_], info->debug_index_);

-  if (info->label_->index_ != Label::kNoIndex)

-    StringAppendF(&s, " (%d)", info->label_->index_);

-

-  StringAppendF(&s, " #%u", info->refs_);

-  return s;

-}

-

-// General graph matching is exponential, essentially trying all permutations.

-// The exponential algorithm can be made faster by avoiding consideration of

-// impossible or unlikely matches.  We can make the matching practical by eager

-// matching - by looking for likely matches and commiting to them, and using the

-// committed assignment as the basis for further matching.

-//

-// The basic eager graph-matching assignment is based on several ideas:

-//

-//  * The strongest match will be for parts of the program that have not

-//    changed.  If part of a program has not changed, then the number of

-//    references to a label will be the same, and corresponding pairs of

-//    adjacent labels will have the same RVA difference.

-//

-//  * Some assignments are 'obvious' if you look at the distribution.  Example:

-//    if both the program and the model have a label that is referred to much

-//    more often than the next most refered-to label, it is likely the two

-//    labels correspond.

-//

-//  * If a label from the program corresponds to a label in the model, it is

-//    likely that the labels near the corresponding labels also match.  A

-//    conservative way of extending the match is to assign only those labels

-//    which have exactly the same address offset and reference count.

-//

-//  * If two labels correspond, then we can try to match up the references

-//    before and after the labels in the reference stream.  For this to be

-//    practical, the number of references has to be small, e.g. each label has

-//    exactly one reference.

-//

-

-// Note: we also tried a completely different approach: random assignment

-// followed by simulated annealing.  This produced similar results.  The results

-// were not as good for very small differences because the simulated annealing

-// never quite hit the groove.  And simulated annealing was several orders of

-// magnitude slower.

-

-

-// TRIE node for suffix strings in the label reference sequence.

-//

-// We dynamically build a trie for both the program and model, growing the trie

-// as necessary.  The trie node for a (possibly) empty string of label

-// references contains the distribution of labels following the string.  The

-// roots node (for the empty string) thus contains the simple distribution of

-// labels within the label reference stream.

-

-struct Node {

-  Node(LabelInfo* in_edge, Node* prev)

-      : in_edge_(in_edge), prev_(prev), count_(0),

-        in_queue_(false) {

-    length_ = 1 + (prev_ ? prev_->length_ : 0);

-  }

-  LabelInfo* in_edge_;  //

-  Node* prev_;          // Node at shorter length.

-  int count_;           // Frequency of this path in Trie.

-  int length_;

-  typedef std::map<LabelInfo*, Node*> Edges;

-  Edges edges_;

-  std::vector<int> places_;   // Indexes into sequence of this item.

-  std::list<Node*> edges_in_frequency_order;

-

-  bool in_queue_;

-  bool Extended() const { return edges_.size() > 0; }

-

-  uint32 Weight() const {

-    return  edges_in_frequency_order.front()->count_;

-  }

-};

-

-static std::string ToString(Node* node) {

-  std::vector<std::string> prefix;

-  for (Node* n = node;  n->prev_;  n = n->prev_)

-    prefix.push_back(ToString(n->in_edge_));

-

-  std::string s;

-  s += "{";

-  const char* sep = "";

-  while (!prefix.empty()) {

-    s += sep;

-    sep = ",";

-    s += prefix.back();

-    prefix.pop_back();

-  }

-

-  s += StringPrintf("%u", node->count_);

-  s += " @";

-  s += Uint64ToString(node->edges_in_frequency_order.size());

-  s += "}";

-  return s;

-}

-

-typedef std::vector<LabelInfo*> Trace;

-

-struct OrderNodeByCountDecreasing {

-  bool operator()(Node* a, Node* b) const {

-    if (a->count_ != b->count_)

-      return  (a->count_) > (b->count_);

-    return a->places_.at(0) < b->places_.at(0);  // Prefer first occuring.

-  }

-};

-

-struct OrderNodeByWeightDecreasing {

-  bool operator()(Node* a, Node* b) const {

-    // (Maybe tie-break on total count, followed by lowest assigned node indexes

-    // in path.)

-    uint32 a_weight = a->Weight();

-    uint32 b_weight = b->Weight();

-    if (a_weight != b_weight)

-      return a_weight > b_weight;

-    if (a->length_ != b->length_)

-      return a->length_ > b->length_;            // Prefer longer.

-    return a->places_.at(0) < b->places_.at(0);  // Prefer first occuring.

-  }

-};

-

-typedef std::set<Node*, OrderNodeByWeightDecreasing> NodeQueue;

-

-class AssignmentProblem {

- public:

-  AssignmentProblem(const Trace& model,

-                    const Trace& problem)

-      : m_trace_(model),

-        p_trace_(problem) {

-  }

-

-  ~AssignmentProblem() {

-    for (size_t i = 0;  i < all_nodes_.size();  ++i)

-      delete all_nodes_[i];

-  }

-

-  bool Solve() {

-    m_root_ = MakeRootNode(m_trace_);

-    p_root_ = MakeRootNode(p_trace_);

-    AddToQueue(p_root_);

-

-    while (!worklist_.empty()) {

-      Node* node = *worklist_.begin();

-      node->in_queue_ = false;

-      worklist_.erase(node);

-      TrySolveNode(node);

-    }

-

-    ALOG1 << unsolved_.size() << " unsolved items";

-    return true;

-  }

-

- private:

-  void AddToQueue(Node* node) {

-    if (node->length_ >= 10) {

-      ALOG3 << "Length clipped " << ToString(node->prev_);

-      return;

-    }

-    if (node->in_queue_) {

-      LOG(ERROR) << "Double add " << ToString(node);

-      return;

-    }

-    // just to be sure data for prioritizing is available

-    ExtendNode(node, p_trace_);

-    // SkipCommittedLabels(node);

-    if (node->edges_in_frequency_order.empty())

-      return;

-    node->in_queue_ = true;

-    worklist_.insert(node);

-  }

-

-  void SkipCommittedLabels(Node* node) {

-    ExtendNode(node, p_trace_);

-    uint32 skipped = 0;

-    while (!node->edges_in_frequency_order.empty() &&

-           node->edges_in_frequency_order.front()->in_edge_->assignment_) {

-      ++skipped;

-      node->edges_in_frequency_order.pop_front();

-    }

-    if (skipped > 0)

-      ALOG3 << "Skipped " << skipped << " at " << ToString(node);

-  }

-

-  void TrySolveNode(Node* p_node) {

-    Node* front = p_node->edges_in_frequency_order.front();

-    if (front->in_edge_->assignment_) {

-      p_node->edges_in_frequency_order.pop_front();

-      AddToQueue(front);

-      AddToQueue(p_node);

-      return;

-    }

-

-    // Compare frequencies of unassigned edges, and either make

-    // assignment(s) or move node to unsolved list

-

-    Node* m_node = FindModelNode(p_node);

-

-    if (m_node == NULL) {

-      ALOG1 << "Can't find model node";

-      unsolved_.insert(p_node);

-      return;

-    }

-    ExtendNode(m_node, m_trace_);

-

-    // Lets just try greedy

-

-    SkipCommittedLabels(m_node);

-    if (m_node->edges_in_frequency_order.empty()) {

-      ALOG3 << "Punting, no elements left in model vs "

-            << p_node->edges_in_frequency_order.size();

-      unsolved_.insert(p_node);

-      return;

-    }

-    Node* m_match = m_node->edges_in_frequency_order.front();

-    Node* p_match = p_node->edges_in_frequency_order.front();

-

-    if (p_match->count_ > 1.1 * m_match->count_  ||

-        m_match->count_ > 1.1 * p_match->count_) {

-      ALOG2 << "Tricky distribution "

-            << p_match->count_ << ":" << m_match->count_ << "  "

-            << ToString(p_match) << " vs " << ToString(m_match);

-      return;

-    }

-

-    m_node->edges_in_frequency_order.pop_front();

-    p_node->edges_in_frequency_order.pop_front();

-

-    LabelInfo* p_label_info = p_match->in_edge_;

-    LabelInfo* m_label_info = m_match->in_edge_;

-    int m_index = p_label_info->label_->index_;

-    if (m_index != Label::kNoIndex) {

-      ALOG1 << "Cant use unassigned label from model " << m_index;

-      unsolved_.insert(p_node);

-      return;

-    }

-

-    Assign(p_label_info, m_label_info);

-

-    AddToQueue(p_match);  // find matches within new match

-    AddToQueue(p_node);   // and more matches within this node

-  }

-

-  void Assign(LabelInfo* p_info, LabelInfo* m_info) {

-    AssignOne(p_info, m_info);

-    ALOG3 << "Assign " << ToString(p_info) << " := " << ToString(m_info);

-    // Now consider unassigned adjacent addresses

-    TryExtendAssignment(p_info, m_info);

-  }

-

-  void AssignOne(LabelInfo* p_info, LabelInfo* m_info) {

-    p_info->label_->index_ = m_info->label_->index_;

-

-    // Mark as assigned

-    m_info->assignment_ = p_info;

-    p_info->assignment_ = m_info;

-  }

-

-  void TryExtendAssignment(LabelInfo* p_info, LabelInfo* m_info) {

-    RVA m_rva_base = m_info->label_->rva_;

-    RVA p_rva_base = p_info->label_->rva_;

-

-    LabelInfo* m_info_next = m_info->next_addr_;

-    LabelInfo* p_info_next = p_info->next_addr_;

-    for ( ; m_info_next && p_info_next; ) {

-      if (m_info_next->assignment_)

-        break;

-

-      RVA m_rva = m_info_next->label_->rva_;

-      RVA p_rva = p_info_next->label_->rva_;

-

-      if (m_rva - m_rva_base != p_rva - p_rva_base) {

-        // previous label was pointing to something that is different size

-        break;

-      }

-      LabelInfo* m_info_next_next = m_info_next->next_addr_;

-      LabelInfo* p_info_next_next = p_info_next->next_addr_;

-      if (m_info_next_next && p_info_next_next) {

-        RVA m_rva_next = m_info_next_next->label_->rva_;

-        RVA p_rva_next = p_info_next_next->label_->rva_;

-        if (m_rva_next - m_rva != p_rva_next - p_rva) {

-          // Since following labels are no longer in address lockstep, assume

-          // this address has a difference.

-          break;

-        }

-      }

-

-      // The label has inconsistent numbers of references, it is probably not

-      // the same thing.

-      if (m_info_next->refs_ != p_info_next->refs_) {

-        break;

-      }

-

-      ALOG3 << "  Extending assignment -> "

-            << ToString(p_info_next) << " := " << ToString(m_info_next);

-

-      AssignOne(p_info_next, m_info_next);

-

-      if (p_info_next->refs_ == m_info_next->refs_ &&

-          p_info_next->refs_ == 1) {

-        TryExtendSequence(p_info_next->positions_[0],

-                          m_info_next->positions_[0]);

-        TryExtendSequenceBackwards(p_info_next->positions_[0],

-                                   m_info_next->positions_[0]);

-      }

-

-      p_info_next = p_info_next_next;

-      m_info_next = m_info_next_next;

-    }

-

-    LabelInfo* m_info_prev = m_info->prev_addr_;

-    LabelInfo* p_info_prev = p_info->prev_addr_;

-    for ( ; m_info_prev && p_info_prev; ) {

-      if (m_info_prev->assignment_)

-        break;

-

-      RVA m_rva = m_info_prev->label_->rva_;

-      RVA p_rva = p_info_prev->label_->rva_;

-

-      if (m_rva - m_rva_base != p_rva - p_rva_base) {

-        // previous label was pointing to something that is different size

-        break;

-      }

-      LabelInfo* m_info_prev_prev = m_info_prev->prev_addr_;

-      LabelInfo* p_info_prev_prev = p_info_prev->prev_addr_;

-

-      // The the label has inconsistent numbers of references, it is

-      // probably not the same thing

-      if (m_info_prev->refs_ != p_info_prev->refs_) {

-        break;

-      }

-

-      AssignOne(p_info_prev, m_info_prev);

-      ALOG3 << "  Extending assignment <- " << ToString(p_info_prev) << " := "

-            << ToString(m_info_prev);

-

-      p_info_prev = p_info_prev_prev;

-      m_info_prev = m_info_prev_prev;

-    }

-  }

-

-  uint32 TryExtendSequence(uint32 p_pos_start, uint32 m_pos_start) {

-    uint32 p_pos = p_pos_start + 1;

-    uint32 m_pos = m_pos_start + 1;

-

-    while (p_pos < p_trace_.size()  &&  m_pos < m_trace_.size()) {

-      LabelInfo* p_info = p_trace_[p_pos];

-      LabelInfo* m_info = m_trace_[m_pos];

-

-      // To match, either (1) both are assigned or (2) both are unassigned.

-      if ((p_info->assignment_ == NULL) != (m_info->assignment_ == NULL))

-        break;

-

-      // If they are assigned, it needs to be consistent (same index).

-      if (p_info->assignment_ && m_info->assignment_) {

-        if (p_info->label_->index_ != m_info->label_->index_)

-          break;

-        ++p_pos;

-        ++m_pos;

-        continue;

-      }

-

-      if (p_info->refs_ != m_info->refs_)

-        break;

-

-      AssignOne(p_info, m_info);

-      ALOG3 << "    Extending assignment seq"

-            << "[+" << p_pos - p_pos_start << "]"

-            << " -> "

-            << ToString(p_info) << " := " << ToString(m_info);

-

-      ++p_pos;

-      ++m_pos;

-    }

-

-    return p_pos - p_pos_start;

-  }

-

-  uint32 TryExtendSequenceBackwards(uint32 p_pos_start, uint32 m_pos_start) {

-    if (p_pos_start == 0  ||  m_pos_start == 0)

-      return 0;

-

-    uint32 p_pos = p_pos_start - 1;

-    uint32 m_pos = m_pos_start - 1;

-

-    while (p_pos > 0  &&  m_pos > 0) {

-      LabelInfo* p_info = p_trace_[p_pos];

-      LabelInfo* m_info = m_trace_[m_pos];

-

-      if ((p_info->assignment_ == NULL) != (m_info->assignment_ == NULL))

-        break;

-

-      if (p_info->assignment_ && m_info->assignment_) {

-        if (p_info->label_->index_ != m_info->label_->index_)

-          break;

-        --p_pos;

-        --m_pos;

-        continue;

-      }

-

-      if (p_info->refs_ != m_info->refs_)

-        break;

-

-      AssignOne(p_info, m_info);

-      ALOG3 << "    Extending assignment seq"

-            << "[-" << p_pos_start - p_pos << "]"

-            << " <- "

-            << ToString(p_info) << " := " << ToString(m_info);

-

-      --p_pos;

-      --m_pos;

-    }

-

-    return p_pos - p_pos_start;

-  }

-

-  Node* FindModelNode(Node* node) {

-    if (node->prev_ == NULL)

-      return m_root_;

-

-    Node* m_parent = FindModelNode(node->prev_);

-    if (m_parent == NULL) {

-      return NULL;

-    }

-

-    ExtendNode(m_parent, m_trace_);

-

-    LabelInfo* p_label = node->in_edge_;

-    LabelInfo* m_label = p_label->assignment_;

-    if (m_label == NULL) {

-      ALOG1 << "Expected assigned prefix";

-      return NULL;

-    }

-

-    Node::Edges::iterator e = m_parent->edges_.find(m_label);

-    if (e == m_parent->edges_.end()) {

-      ALOG2 << "Expected defined edge in parent";

-      return NULL;

-    }

-

-    return e->second;

-  }

-

-  Node* MakeRootNode(const Trace& trace) {

-    Node* node = new Node(NULL, NULL);

-    all_nodes_.push_back(node);

-    for (size_t i = 0;  i < trace.size();  ++i) {

-      ++node->count_;

-      node->places_.push_back(i);

-    }

-    return node;

-  }

-

-  void ExtendNode(Node* node, const Trace& trace) {

-    // Make sure trie is filled in at this node.

-    if (node->Extended())

-      return;

-    for (size_t i = 0; i < node->places_.size();  ++i) {

-      uint32 index = node->places_.at(i);

-      if (index < trace.size()) {

-        LabelInfo* item = trace.at(index);

-        Node*& slot = node->edges_[item];

-        if (slot == NULL) {

-          slot = new Node(item, node);

-          all_nodes_.push_back(slot);

-          node->edges_in_frequency_order.push_back(slot);

-        }

-        slot->places_.push_back(index + 1);

-        ++slot->count_;

-      }

-    }

-    node->edges_in_frequency_order.sort(OrderNodeByCountDecreasing());

-  }

-

-  const Trace& m_trace_;

-  const Trace& p_trace_;

-  Node* m_root_;

-  Node* p_root_;

-

-  NodeQueue worklist_;

-  NodeQueue unsolved_;

-

-  std::vector<Node*> all_nodes_;

-

-  DISALLOW_COPY_AND_ASSIGN(AssignmentProblem);

-};

-

-class GraphAdjuster : public AdjustmentMethod {

- public:

-  GraphAdjuster() {}

-  ~GraphAdjuster() {}

-

-  bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {

-    LOG(INFO) << "GraphAdjuster::Adjust";

-    prog_ = program;

-    model_ = &model;

-    debug_label_index_gen_ = 0;

-    return Finish();

-  }

-

-  bool Finish() {

-    prog_->UnassignIndexes();

-    CollectTraces(model_, &model_abs32_, &model_rel32_, true);

-    CollectTraces(prog_,  &prog_abs32_,  &prog_rel32_,  false);

-    Solve(model_abs32_, prog_abs32_);

-    Solve(model_rel32_, prog_rel32_);

-    prog_->AssignRemainingIndexes();

-    return true;

-  }

-

- private:

-

-  void CollectTraces(const AssemblyProgram* program, Trace* abs32, Trace* rel32,

-                     bool is_model) {

-    const std::vector<Instruction*>& instructions = program->instructions();

-    for (size_t i = 0;  i < instructions.size();  ++i) {

-      Instruction* instruction = instructions.at(i);

-      if (Label* label = program->InstructionAbs32Label(instruction))

-        ReferenceLabel(abs32, label, is_model);

-      if (Label* label = program->InstructionRel32Label(instruction))

-        ReferenceLabel(rel32, label, is_model);

-    }

-    // TODO(sra): we could simply append all the labels in index order to

-    // incorporate some costing for entropy (bigger deltas) that will be

-    // introduced into the label address table by non-monotonic ordering.  This

-    // would have some knock-on effects to parts of the algorithm that work on

-    // single-occurence labels.

-  }

-

-  void Solve(const Trace& model, const Trace& problem) {

-    LinkLabelInfos(model);

-    LinkLabelInfos(problem);

-    AssignmentProblem a(model, problem);

-    a.Solve();

-  }

-

-  void LinkLabelInfos(const Trace& trace) {

-    typedef std::set<LabelInfo*, OrderLabelInfoByAddressAscending> Ordered;

-    Ordered ordered;

-    for (Trace::const_iterator p = trace.begin();  p != trace.end();  ++p)

-      ordered.insert(*p);

-    LabelInfo* prev = NULL;

-    for (Ordered::iterator p = ordered.begin();  p != ordered.end();  ++p) {

-      LabelInfo* curr = *p;

-      if (prev) prev->next_addr_ = curr;

-      curr->prev_addr_ = prev;

-      prev = curr;

-

-      if (curr->positions_.size() != curr->refs_)

-        NOTREACHED();

-    }

-  }

-

-  void ReferenceLabel(Trace* trace, Label* label, bool is_model) {

-    trace->push_back(MakeLabelInfo(label, is_model, trace->size()));

-  }

-

-  LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32 position) {

-    LabelInfo& slot = label_infos_[label];

-    if (slot.label_ == NULL) {

-      slot.label_ = label;

-      slot.is_model_ = is_model;

-      slot.debug_index_ = ++debug_label_index_gen_;

-    }

-    slot.positions_.push_back(position);

-    ++slot.refs_;

-    return &slot;

-  }

-

-  AssemblyProgram* prog_;         // Program to be adjusted, owned by caller.

-  const AssemblyProgram* model_;  // Program to be mimicked, owned by caller.

-

-  Trace model_abs32_;

-  Trace model_rel32_;

-  Trace prog_abs32_;

-  Trace prog_rel32_;

-

-  int debug_label_index_gen_;

-

-  // Note LabelInfo is allocated inside map, so the LabelInfo lifetimes are

-  // managed by the map.

-  std::map<Label*, LabelInfo> label_infos_;

-

- private:

-  DISALLOW_COPY_AND_ASSIGN(GraphAdjuster);

-};

-

-

-////////////////////////////////////////////////////////////////////////////////

-

-void AdjustmentMethod::Destroy() { delete this; }

-

-AdjustmentMethod* AdjustmentMethod::MakeNullAdjustmentMethod() {

-  return new NullAdjustmentMethod();

-}

-

-AdjustmentMethod* AdjustmentMethod::MakeProductionAdjustmentMethod() {

-  return new GraphAdjuster();

-}

-

-Status Adjust(const AssemblyProgram& model, AssemblyProgram* program) {

-  AdjustmentMethod* method = AdjustmentMethod::MakeProductionAdjustmentMethod();

-  bool ok = method->Adjust(model, program);

-  method->Destroy();

-  if (ok)

-    return C_OK;

-  else

-    return C_ADJUSTMENT_FAILED;

-}

-

-}  // namespace courgette

+// Copyright (c) 2009 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.
+
+#include "courgette/adjustment_method.h"
+
+#include <algorithm>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+
+#include "courgette/assembly_program.h"
+#include "courgette/courgette.h"
+#include "courgette/encoded_program.h"
+#include "courgette/image_info.h"
+
+namespace courgette {
+
+// We have three discretionary information logging levels for algorithm
+// development.  For now just configure with #defines.
+// TODO(sra): make dependent of some configurable setting.
+#define NO_LOG DLOG_IF(INFO, false)
+// #define ALOG1 LOG(INFO)
+// #define ALOG2 LOG(INFO)
+// #define ALOG3 LOG(INFO)
+#define ALOG1 NO_LOG
+#define ALOG2 NO_LOG
+#define ALOG3 NO_LOG
+
+////////////////////////////////////////////////////////////////////////////////
+
+class NullAdjustmentMethod : public AdjustmentMethod {
+  bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
+    return true;
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// The purpose of adjustment is to assign indexes to Labels of a program 'p' to
+// make the sequence of indexes similar to a 'model' program 'm'.  Labels
+// themselves don't have enough information to do this job, so we work with a
+// LabelInfo surrogate for each label.
+//
+class LabelInfo {
+ public:
+  Label* label_;              // The label that this info a surrogate for.
+
+  // Information used only in debugging messages.
+  uint32 is_model_ : 1;       // Is the label in the model?
+  uint32 debug_index_ : 31;   // An unique small number for naming the label.
+
+  uint32 refs_;               // Number of times this Label is referenced.
+
+  LabelInfo* assignment_;     // Label from other program corresponding to this.
+
+  // LabelInfos are in a doubly linked list ordered by address (label_->rva_) so
+  // we can quickly find Labels adjacent in address order.
+  LabelInfo* next_addr_;      // Label(Info) at next highest address.
+  LabelInfo* prev_addr_;      // Label(Info) at next lowest address.
+
+  std::vector<uint32> positions_;  // Offsets into the trace of references.
+
+  // Just a no-argument constructor and copy constructor.  Actual LabelInfo
+  // objects are allocated in std::pair structs in a std::map.
+  LabelInfo()
+      : label_(NULL), is_model_(false), debug_index_(0), refs_(0),
+        assignment_(NULL),
+        next_addr_(NULL),
+        prev_addr_(NULL) {}
+
+ private:
+  void operator=(const LabelInfo*);  // Disallow assignment only.
+
+  // Public compiler generated copy constructor is needed to constuct
+  // std::pair<Label*, LabelInfo> so that fresh LabelInfos can be allocated
+  // inside a std::map.
+};
+
+struct OrderLabelInfoByAddressAscending {
+  bool operator()(const LabelInfo* a, const LabelInfo* b) const {
+    return a->label_->rva_ < b->label_->rva_;
+  }
+};
+
+static std::string ToString(LabelInfo* info) {
+  std::string s;
+  StringAppendF(&s, "%c%d", "pm"[info->is_model_], info->debug_index_);
+  if (info->label_->index_ != Label::kNoIndex)
+    StringAppendF(&s, " (%d)", info->label_->index_);
+
+  StringAppendF(&s, " #%u", info->refs_);
+  return s;
+}
+
+// General graph matching is exponential, essentially trying all permutations.
+// The exponential algorithm can be made faster by avoiding consideration of
+// impossible or unlikely matches.  We can make the matching practical by eager
+// matching - by looking for likely matches and commiting to them, and using the
+// committed assignment as the basis for further matching.
+//
+// The basic eager graph-matching assignment is based on several ideas:
+//
+//  * The strongest match will be for parts of the program that have not
+//    changed.  If part of a program has not changed, then the number of
+//    references to a label will be the same, and corresponding pairs of
+//    adjacent labels will have the same RVA difference.
+//
+//  * Some assignments are 'obvious' if you look at the distribution.  Example:
+//    if both the program and the model have a label that is referred to much
+//    more often than the next most refered-to label, it is likely the two
+//    labels correspond.
+//
+//  * If a label from the program corresponds to a label in the model, it is
+//    likely that the labels near the corresponding labels also match.  A
+//    conservative way of extending the match is to assign only those labels
+//    which have exactly the same address offset and reference count.
+//
+//  * If two labels correspond, then we can try to match up the references
+//    before and after the labels in the reference stream.  For this to be
+//    practical, the number of references has to be small, e.g. each label has
+//    exactly one reference.
+//
+
+// Note: we also tried a completely different approach: random assignment
+// followed by simulated annealing.  This produced similar results.  The results
+// were not as good for very small differences because the simulated annealing
+// never quite hit the groove.  And simulated annealing was several orders of
+// magnitude slower.
+
+
+// TRIE node for suffix strings in the label reference sequence.
+//
+// We dynamically build a trie for both the program and model, growing the trie
+// as necessary.  The trie node for a (possibly) empty string of label
+// references contains the distribution of labels following the string.  The
+// roots node (for the empty string) thus contains the simple distribution of
+// labels within the label reference stream.
+
+struct Node {
+  Node(LabelInfo* in_edge, Node* prev)
+      : in_edge_(in_edge), prev_(prev), count_(0),
+        in_queue_(false) {
+    length_ = 1 + (prev_ ? prev_->length_ : 0);
+  }
+  LabelInfo* in_edge_;  //
+  Node* prev_;          // Node at shorter length.
+  int count_;           // Frequency of this path in Trie.
+  int length_;
+  typedef std::map<LabelInfo*, Node*> Edges;
+  Edges edges_;
+  std::vector<int> places_;   // Indexes into sequence of this item.
+  std::list<Node*> edges_in_frequency_order;
+
+  bool in_queue_;
+  bool Extended() const { return edges_.size() > 0; }
+
+  uint32 Weight() const {
+    return  edges_in_frequency_order.front()->count_;
+  }
+};
+
+static std::string ToString(Node* node) {
+  std::vector<std::string> prefix;
+  for (Node* n = node;  n->prev_;  n = n->prev_)
+    prefix.push_back(ToString(n->in_edge_));
+
+  std::string s;
+  s += "{";
+  const char* sep = "";
+  while (!prefix.empty()) {
+    s += sep;
+    sep = ",";
+    s += prefix.back();
+    prefix.pop_back();
+  }
+
+  s += StringPrintf("%u", node->count_);
+  s += " @";
+  s += Uint64ToString(node->edges_in_frequency_order.size());
+  s += "}";
+  return s;
+}
+
+typedef std::vector<LabelInfo*> Trace;
+
+struct OrderNodeByCountDecreasing {
+  bool operator()(Node* a, Node* b) const {
+    if (a->count_ != b->count_)
+      return  (a->count_) > (b->count_);
+    return a->places_.at(0) < b->places_.at(0);  // Prefer first occuring.
+  }
+};
+
+struct OrderNodeByWeightDecreasing {
+  bool operator()(Node* a, Node* b) const {
+    // (Maybe tie-break on total count, followed by lowest assigned node indexes
+    // in path.)
+    uint32 a_weight = a->Weight();
+    uint32 b_weight = b->Weight();
+    if (a_weight != b_weight)
+      return a_weight > b_weight;
+    if (a->length_ != b->length_)
+      return a->length_ > b->length_;            // Prefer longer.
+    return a->places_.at(0) < b->places_.at(0);  // Prefer first occuring.
+  }
+};
+
+typedef std::set<Node*, OrderNodeByWeightDecreasing> NodeQueue;
+
+class AssignmentProblem {
+ public:
+  AssignmentProblem(const Trace& model,
+                    const Trace& problem)
+      : m_trace_(model),
+        p_trace_(problem) {
+  }
+
+  ~AssignmentProblem() {
+    for (size_t i = 0;  i < all_nodes_.size();  ++i)
+      delete all_nodes_[i];
+  }
+
+  bool Solve() {
+    m_root_ = MakeRootNode(m_trace_);
+    p_root_ = MakeRootNode(p_trace_);
+    AddToQueue(p_root_);
+
+    while (!worklist_.empty()) {
+      Node* node = *worklist_.begin();
+      node->in_queue_ = false;
+      worklist_.erase(node);
+      TrySolveNode(node);
+    }
+
+    ALOG1 << unsolved_.size() << " unsolved items";
+    return true;
+  }
+
+ private:
+  void AddToQueue(Node* node) {
+    if (node->length_ >= 10) {
+      ALOG3 << "Length clipped " << ToString(node->prev_);
+      return;
+    }
+    if (node->in_queue_) {
+      LOG(ERROR) << "Double add " << ToString(node);
+      return;
+    }
+    // just to be sure data for prioritizing is available
+    ExtendNode(node, p_trace_);
+    // SkipCommittedLabels(node);
+    if (node->edges_in_frequency_order.empty())
+      return;
+    node->in_queue_ = true;
+    worklist_.insert(node);
+  }
+
+  void SkipCommittedLabels(Node* node) {
+    ExtendNode(node, p_trace_);
+    uint32 skipped = 0;
+    while (!node->edges_in_frequency_order.empty() &&
+           node->edges_in_frequency_order.front()->in_edge_->assignment_) {
+      ++skipped;
+      node->edges_in_frequency_order.pop_front();
+    }
+    if (skipped > 0)
+      ALOG3 << "Skipped " << skipped << " at " << ToString(node);
+  }
+
+  void TrySolveNode(Node* p_node) {
+    Node* front = p_node->edges_in_frequency_order.front();
+    if (front->in_edge_->assignment_) {
+      p_node->edges_in_frequency_order.pop_front();
+      AddToQueue(front);
+      AddToQueue(p_node);
+      return;
+    }
+
+    // Compare frequencies of unassigned edges, and either make
+    // assignment(s) or move node to unsolved list
+
+    Node* m_node = FindModelNode(p_node);
+
+    if (m_node == NULL) {
+      ALOG1 << "Can't find model node";
+      unsolved_.insert(p_node);
+      return;
+    }
+    ExtendNode(m_node, m_trace_);
+
+    // Lets just try greedy
+
+    SkipCommittedLabels(m_node);
+    if (m_node->edges_in_frequency_order.empty()) {
+      ALOG3 << "Punting, no elements left in model vs "
+            << p_node->edges_in_frequency_order.size();
+      unsolved_.insert(p_node);
+      return;
+    }
+    Node* m_match = m_node->edges_in_frequency_order.front();
+    Node* p_match = p_node->edges_in_frequency_order.front();
+
+    if (p_match->count_ > 1.1 * m_match->count_  ||
+        m_match->count_ > 1.1 * p_match->count_) {
+      ALOG2 << "Tricky distribution "
+            << p_match->count_ << ":" << m_match->count_ << "  "
+            << ToString(p_match) << " vs " << ToString(m_match);
+      return;
+    }
+
+    m_node->edges_in_frequency_order.pop_front();
+    p_node->edges_in_frequency_order.pop_front();
+
+    LabelInfo* p_label_info = p_match->in_edge_;
+    LabelInfo* m_label_info = m_match->in_edge_;
+    int m_index = p_label_info->label_->index_;
+    if (m_index != Label::kNoIndex) {
+      ALOG1 << "Cant use unassigned label from model " << m_index;
+      unsolved_.insert(p_node);
+      return;
+    }
+
+    Assign(p_label_info, m_label_info);
+
+    AddToQueue(p_match);  // find matches within new match
+    AddToQueue(p_node);   // and more matches within this node
+  }
+
+  void Assign(LabelInfo* p_info, LabelInfo* m_info) {
+    AssignOne(p_info, m_info);
+    ALOG3 << "Assign " << ToString(p_info) << " := " << ToString(m_info);
+    // Now consider unassigned adjacent addresses
+    TryExtendAssignment(p_info, m_info);
+  }
+
+  void AssignOne(LabelInfo* p_info, LabelInfo* m_info) {
+    p_info->label_->index_ = m_info->label_->index_;
+
+    // Mark as assigned
+    m_info->assignment_ = p_info;
+    p_info->assignment_ = m_info;
+  }
+
+  void TryExtendAssignment(LabelInfo* p_info, LabelInfo* m_info) {
+    RVA m_rva_base = m_info->label_->rva_;
+    RVA p_rva_base = p_info->label_->rva_;
+
+    LabelInfo* m_info_next = m_info->next_addr_;
+    LabelInfo* p_info_next = p_info->next_addr_;
+    for ( ; m_info_next && p_info_next; ) {
+      if (m_info_next->assignment_)
+        break;
+
+      RVA m_rva = m_info_next->label_->rva_;
+      RVA p_rva = p_info_next->label_->rva_;
+
+      if (m_rva - m_rva_base != p_rva - p_rva_base) {
+        // previous label was pointing to something that is different size
+        break;
+      }
+      LabelInfo* m_info_next_next = m_info_next->next_addr_;
+      LabelInfo* p_info_next_next = p_info_next->next_addr_;
+      if (m_info_next_next && p_info_next_next) {
+        RVA m_rva_next = m_info_next_next->label_->rva_;
+        RVA p_rva_next = p_info_next_next->label_->rva_;
+        if (m_rva_next - m_rva != p_rva_next - p_rva) {
+          // Since following labels are no longer in address lockstep, assume
+          // this address has a difference.
+          break;
+        }
+      }
+
+      // The label has inconsistent numbers of references, it is probably not
+      // the same thing.
+      if (m_info_next->refs_ != p_info_next->refs_) {
+        break;
+      }
+
+      ALOG3 << "  Extending assignment -> "
+            << ToString(p_info_next) << " := " << ToString(m_info_next);
+
+      AssignOne(p_info_next, m_info_next);
+
+      if (p_info_next->refs_ == m_info_next->refs_ &&
+          p_info_next->refs_ == 1) {
+        TryExtendSequence(p_info_next->positions_[0],
+                          m_info_next->positions_[0]);
+        TryExtendSequenceBackwards(p_info_next->positions_[0],
+                                   m_info_next->positions_[0]);
+      }
+
+      p_info_next = p_info_next_next;
+      m_info_next = m_info_next_next;
+    }
+
+    LabelInfo* m_info_prev = m_info->prev_addr_;
+    LabelInfo* p_info_prev = p_info->prev_addr_;
+    for ( ; m_info_prev && p_info_prev; ) {
+      if (m_info_prev->assignment_)
+        break;
+
+      RVA m_rva = m_info_prev->label_->rva_;
+      RVA p_rva = p_info_prev->label_->rva_;
+
+      if (m_rva - m_rva_base != p_rva - p_rva_base) {
+        // previous label was pointing to something that is different size
+        break;
+      }
+      LabelInfo* m_info_prev_prev = m_info_prev->prev_addr_;
+      LabelInfo* p_info_prev_prev = p_info_prev->prev_addr_;
+
+      // The the label has inconsistent numbers of references, it is
+      // probably not the same thing
+      if (m_info_prev->refs_ != p_info_prev->refs_) {
+        break;
+      }
+
+      AssignOne(p_info_prev, m_info_prev);
+      ALOG3 << "  Extending assignment <- " << ToString(p_info_prev) << " := "
+            << ToString(m_info_prev);
+
+      p_info_prev = p_info_prev_prev;
+      m_info_prev = m_info_prev_prev;
+    }
+  }
+
+  uint32 TryExtendSequence(uint32 p_pos_start, uint32 m_pos_start) {
+    uint32 p_pos = p_pos_start + 1;
+    uint32 m_pos = m_pos_start + 1;
+
+    while (p_pos < p_trace_.size()  &&  m_pos < m_trace_.size()) {
+      LabelInfo* p_info = p_trace_[p_pos];
+      LabelInfo* m_info = m_trace_[m_pos];
+
+      // To match, either (1) both are assigned or (2) both are unassigned.
+      if ((p_info->assignment_ == NULL) != (m_info->assignment_ == NULL))
+        break;
+
+      // If they are assigned, it needs to be consistent (same index).
+      if (p_info->assignment_ && m_info->assignment_) {
+        if (p_info->label_->index_ != m_info->label_->index_)
+          break;
+        ++p_pos;
+        ++m_pos;
+        continue;
+      }
+
+      if (p_info->refs_ != m_info->refs_)
+        break;
+
+      AssignOne(p_info, m_info);
+      ALOG3 << "    Extending assignment seq"
+            << "[+" << p_pos - p_pos_start << "]"
+            << " -> "
+            << ToString(p_info) << " := " << ToString(m_info);
+
+      ++p_pos;
+      ++m_pos;
+    }
+
+    return p_pos - p_pos_start;
+  }
+
+  uint32 TryExtendSequenceBackwards(uint32 p_pos_start, uint32 m_pos_start) {
+    if (p_pos_start == 0  ||  m_pos_start == 0)
+      return 0;
+
+    uint32 p_pos = p_pos_start - 1;
+    uint32 m_pos = m_pos_start - 1;
+
+    while (p_pos > 0  &&  m_pos > 0) {
+      LabelInfo* p_info = p_trace_[p_pos];
+      LabelInfo* m_info = m_trace_[m_pos];
+
+      if ((p_info->assignment_ == NULL) != (m_info->assignment_ == NULL))
+        break;
+
+      if (p_info->assignment_ && m_info->assignment_) {
+        if (p_info->label_->index_ != m_info->label_->index_)
+          break;
+        --p_pos;
+        --m_pos;
+        continue;
+      }
+
+      if (p_info->refs_ != m_info->refs_)
+        break;
+
+      AssignOne(p_info, m_info);
+      ALOG3 << "    Extending assignment seq"
+            << "[-" << p_pos_start - p_pos << "]"
+            << " <- "
+            << ToString(p_info) << " := " << ToString(m_info);
+
+      --p_pos;
+      --m_pos;
+    }
+
+    return p_pos - p_pos_start;
+  }
+
+  Node* FindModelNode(Node* node) {
+    if (node->prev_ == NULL)
+      return m_root_;
+
+    Node* m_parent = FindModelNode(node->prev_);
+    if (m_parent == NULL) {
+      return NULL;
+    }
+
+    ExtendNode(m_parent, m_trace_);
+
+    LabelInfo* p_label = node->in_edge_;
+    LabelInfo* m_label = p_label->assignment_;
+    if (m_label == NULL) {
+      ALOG1 << "Expected assigned prefix";
+      return NULL;
+    }
+
+    Node::Edges::iterator e = m_parent->edges_.find(m_label);
+    if (e == m_parent->edges_.end()) {
+      ALOG2 << "Expected defined edge in parent";
+      return NULL;
+    }
+
+    return e->second;
+  }
+
+  Node* MakeRootNode(const Trace& trace) {
+    Node* node = new Node(NULL, NULL);
+    all_nodes_.push_back(node);
+    for (size_t i = 0;  i < trace.size();  ++i) {
+      ++node->count_;
+      node->places_.push_back(i);
+    }
+    return node;
+  }
+
+  void ExtendNode(Node* node, const Trace& trace) {
+    // Make sure trie is filled in at this node.
+    if (node->Extended())
+      return;
+    for (size_t i = 0; i < node->places_.size();  ++i) {
+      uint32 index = node->places_.at(i);
+      if (index < trace.size()) {
+        LabelInfo* item = trace.at(index);
+        Node*& slot = node->edges_[item];
+        if (slot == NULL) {
+          slot = new Node(item, node);
+          all_nodes_.push_back(slot);
+          node->edges_in_frequency_order.push_back(slot);
+        }
+        slot->places_.push_back(index + 1);
+        ++slot->count_;
+      }
+    }
+    node->edges_in_frequency_order.sort(OrderNodeByCountDecreasing());
+  }
+
+  const Trace& m_trace_;
+  const Trace& p_trace_;
+  Node* m_root_;
+  Node* p_root_;
+
+  NodeQueue worklist_;
+  NodeQueue unsolved_;
+
+  std::vector<Node*> all_nodes_;
+
+  DISALLOW_COPY_AND_ASSIGN(AssignmentProblem);
+};
+
+class GraphAdjuster : public AdjustmentMethod {
+ public:
+  GraphAdjuster() {}
+  ~GraphAdjuster() {}
+
+  bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
+    LOG(INFO) << "GraphAdjuster::Adjust";
+    prog_ = program;
+    model_ = &model;
+    debug_label_index_gen_ = 0;
+    return Finish();
+  }
+
+  bool Finish() {
+    prog_->UnassignIndexes();
+    CollectTraces(model_, &model_abs32_, &model_rel32_, true);
+    CollectTraces(prog_,  &prog_abs32_,  &prog_rel32_,  false);
+    Solve(model_abs32_, prog_abs32_);
+    Solve(model_rel32_, prog_rel32_);
+    prog_->AssignRemainingIndexes();
+    return true;
+  }
+
+ private:
+
+  void CollectTraces(const AssemblyProgram* program, Trace* abs32, Trace* rel32,
+                     bool is_model) {
+    const std::vector<Instruction*>& instructions = program->instructions();
+    for (size_t i = 0;  i < instructions.size();  ++i) {
+      Instruction* instruction = instructions.at(i);
+      if (Label* label = program->InstructionAbs32Label(instruction))
+        ReferenceLabel(abs32, label, is_model);
+      if (Label* label = program->InstructionRel32Label(instruction))
+        ReferenceLabel(rel32, label, is_model);
+    }
+    // TODO(sra): we could simply append all the labels in index order to
+    // incorporate some costing for entropy (bigger deltas) that will be
+    // introduced into the label address table by non-monotonic ordering.  This
+    // would have some knock-on effects to parts of the algorithm that work on
+    // single-occurence labels.
+  }
+
+  void Solve(const Trace& model, const Trace& problem) {
+    LinkLabelInfos(model);
+    LinkLabelInfos(problem);
+    AssignmentProblem a(model, problem);
+    a.Solve();
+  }
+
+  void LinkLabelInfos(const Trace& trace) {
+    typedef std::set<LabelInfo*, OrderLabelInfoByAddressAscending> Ordered;
+    Ordered ordered;
+    for (Trace::const_iterator p = trace.begin();  p != trace.end();  ++p)
+      ordered.insert(*p);
+    LabelInfo* prev = NULL;
+    for (Ordered::iterator p = ordered.begin();  p != ordered.end();  ++p) {
+      LabelInfo* curr = *p;
+      if (prev) prev->next_addr_ = curr;
+      curr->prev_addr_ = prev;
+      prev = curr;
+
+      if (curr->positions_.size() != curr->refs_)
+        NOTREACHED();
+    }
+  }
+
+  void ReferenceLabel(Trace* trace, Label* label, bool is_model) {
+    trace->push_back(MakeLabelInfo(label, is_model, trace->size()));
+  }
+
+  LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32 position) {
+    LabelInfo& slot = label_infos_[label];
+    if (slot.label_ == NULL) {
+      slot.label_ = label;
+      slot.is_model_ = is_model;
+      slot.debug_index_ = ++debug_label_index_gen_;
+    }
+    slot.positions_.push_back(position);
+    ++slot.refs_;
+    return &slot;
+  }
+
+  AssemblyProgram* prog_;         // Program to be adjusted, owned by caller.
+  const AssemblyProgram* model_;  // Program to be mimicked, owned by caller.
+
+  Trace model_abs32_;
+  Trace model_rel32_;
+  Trace prog_abs32_;
+  Trace prog_rel32_;
+
+  int debug_label_index_gen_;
+
+  // Note LabelInfo is allocated inside map, so the LabelInfo lifetimes are
+  // managed by the map.
+  std::map<Label*, LabelInfo> label_infos_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(GraphAdjuster);
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AdjustmentMethod::Destroy() { delete this; }
+
+AdjustmentMethod* AdjustmentMethod::MakeNullAdjustmentMethod() {
+  return new NullAdjustmentMethod();
+}
+
+AdjustmentMethod* AdjustmentMethod::MakeProductionAdjustmentMethod() {
+  return new GraphAdjuster();
+}
+
+Status Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
+  AdjustmentMethod* method = AdjustmentMethod::MakeProductionAdjustmentMethod();
+  bool ok = method->Adjust(model, program);
+  method->Destroy();
+  if (ok)
+    return C_OK;
+  else
+    return C_ADJUSTMENT_FAILED;
+}
+
+}  // namespace courgette
diff --git a/third_party/courgette/adjustment_method.h b/courgette/adjustment_method.h
index 2a5b0c7..8ca71e8 100644
--- a/third_party/courgette/adjustment_method.h
+++ b/courgette/adjustment_method.h
@@ -1,43 +1,42 @@
-// Copyright (c) 2009 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.

-

-#ifndef COURGETTE_ADJUSTMENT_METHOD_H_

-#define COURGETTE_ADJUSTMENT_METHOD_H_

-

-#include "base/basictypes.h"

-

-namespace courgette {

-

-class AssemblyProgram;

-

-class AdjustmentMethod {

- public:

-  // Factory methods for making adjusters.

-

-  // Returns the adjustment method used in production.

-  static AdjustmentMethod* MakeProductionAdjustmentMethod();

-

-  // Returns and adjustement method that makes no adjustments.

-  static AdjustmentMethod* MakeNullAdjustmentMethod();

-

-

-  // Adjusts |program| to increase similarity to |model|.  |program| can be

-  // changed in any way provided that it still produces the same output when

-  // assembled.

-  virtual bool Adjust(const AssemblyProgram& model,

-                      AssemblyProgram* program) = 0;

-

-  // Deletes 'this' adjustment method.

-  virtual void Destroy();

-

- protected:

-  AdjustmentMethod() {}

-  virtual ~AdjustmentMethod() {}

-

-  DISALLOW_COPY_AND_ASSIGN(AdjustmentMethod);

-};

-

-}  // namespace courgette

-#endif  // COURGETTE_ADJUSTMENT_METHOD_H_

-

+// Copyright (c) 2009 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.
+
+#ifndef COURGETTE_ADJUSTMENT_METHOD_H_
+#define COURGETTE_ADJUSTMENT_METHOD_H_
+
+#include "base/basictypes.h"
+
+namespace courgette {
+
+class AssemblyProgram;
+
+class AdjustmentMethod {
+ public:
+  // Factory methods for making adjusters.
+
+  // Returns the adjustment method used in production.
+  static AdjustmentMethod* MakeProductionAdjustmentMethod();
+
+  // Returns and adjustement method that makes no adjustments.
+  static AdjustmentMethod* MakeNullAdjustmentMethod();
+
+
+  // Adjusts |program| to increase similarity to |model|.  |program| can be
+  // changed in any way provided that it still produces the same output when
+  // assembled.
+  virtual bool Adjust(const AssemblyProgram& model,
+                      AssemblyProgram* program) = 0;
+
+  // Deletes 'this' adjustment method.
+  virtual void Destroy();
+
+ protected:
+  AdjustmentMethod() {}
+  virtual ~AdjustmentMethod() {}
+
+  DISALLOW_COPY_AND_ASSIGN(AdjustmentMethod);
+};
+
+}  // namespace courgette
+#endif  // COURGETTE_ADJUSTMENT_METHOD_H_
diff --git a/third_party/courgette/adjustment_method_unittest.cc b/courgette/adjustment_method_unittest.cc
index 2048126..661b23d 100644
--- a/third_party/courgette/adjustment_method_unittest.cc
+++ b/courgette/adjustment_method_unittest.cc
@@ -1,109 +1,108 @@
-// Copyright (c) 2009 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.

-

-#include <string>

-

-#include "base/path_service.h"

-#include "base/file_util.h"

-#include "base/string_util.h"

-

-#include "third_party/courgette/assembly_program.h"

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/streams.h"

-

-#include "testing/gtest/include/gtest/gtest.h"

-

-class AdjustmentMethodTest : public testing::Test {

- public:

-  void Test1() const;

-

- private:

-  void SetUp() {

-  }

-

-  void TearDown() {

-  }

-

-  // Returns one of two similar a simple programs.  They differ only in the

-  // label assignment, so that it is possible to make them look identical.

-  courgette::AssemblyProgram* MakeProgram(int kind) const {

-    courgette::AssemblyProgram* prog = new courgette::AssemblyProgram();

-    prog->set_image_base(0x00400000);

-

-    courgette::Label* labelA = prog->FindOrMakeAbs32Label(0x00410000);

-    courgette::Label* labelB = prog->FindOrMakeAbs32Label(0x00410004);

-

-    prog->EmitAbs32(labelA);

-    prog->EmitAbs32(labelA);

-    prog->EmitAbs32(labelB);

-    prog->EmitAbs32(labelA);

-    prog->EmitAbs32(labelA);

-    prog->EmitAbs32(labelB);

-

-    if (kind == 0) {

-      labelA->index_ = 0;

-      labelB->index_ = 1;

-    } else {

-      labelA->index_ = 1;

-      labelB->index_ = 0;

-    }

-    prog->AssignRemainingIndexes();

-

-    return prog;

-  }

-

-  courgette::AssemblyProgram* MakeProgramA() const { return MakeProgram(0); }

-  courgette::AssemblyProgram* MakeProgramB() const { return MakeProgram(1); }

-

-  // Returns a string that is the serialized version of |program|.

-  // Deletes |program|.

-  std::string Serialize(courgette::AssemblyProgram *program) const {

-    courgette::EncodedProgram* encoded = NULL;

-

-    const courgette::Status encode_status = Encode(program, &encoded);

-    EXPECT_EQ(courgette::C_OK, encode_status);

-

-    DeleteAssemblyProgram(program);

-

-    courgette::SinkStreamSet sinks;

-    const courgette::Status write_status = WriteEncodedProgram(encoded, &sinks);

-    EXPECT_EQ(courgette::C_OK, write_status);

-

-    DeleteEncodedProgram(encoded);

-

-    courgette::SinkStream sink;

-    bool can_collect = sinks.CopyTo(&sink);

-    EXPECT_TRUE(can_collect);

-

-    return std::string(reinterpret_cast<const char *>(sink.Buffer()),

-                       sink.Length());

-  }

-};

-

-

-void AdjustmentMethodTest::Test1() const {

-  courgette::AssemblyProgram* prog1 = MakeProgramA();

-  courgette::AssemblyProgram* prog2 = MakeProgramB();

-  std::string s1 = Serialize(prog1);

-  std::string s2 = Serialize(prog2);

-

-  // Don't use EXPECT_EQ because strings are unprintable.

-  EXPECT_FALSE(s1 == s2);  // Unadjusted A and B differ.

-

-  courgette::AssemblyProgram* prog5 = MakeProgramA();

-  courgette::AssemblyProgram* prog6 = MakeProgramB();

-  courgette::Status can_adjust = Adjust(*prog5, prog6);

-  EXPECT_EQ(courgette::C_OK, can_adjust);

-  std::string s5 = Serialize(prog5);

-  std::string s6 = Serialize(prog6);

-

-  EXPECT_TRUE(s1 == s5);  // Adjustment did not change A (prog5)

-  EXPECT_TRUE(s5 == s6);  // Adjustment did change B into A

-}

-

-

-TEST_F(AdjustmentMethodTest, All) {

-  Test1();

-}

-

+// Copyright (c) 2009 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.
+
+#include <string>
+
+#include "base/path_service.h"
+#include "base/file_util.h"
+#include "base/string_util.h"
+
+#include "courgette/assembly_program.h"
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+class AdjustmentMethodTest : public testing::Test {
+ public:
+  void Test1() const;
+
+ private:
+  void SetUp() {
+  }
+
+  void TearDown() {
+  }
+
+  // Returns one of two similar a simple programs.  They differ only in the
+  // label assignment, so that it is possible to make them look identical.
+  courgette::AssemblyProgram* MakeProgram(int kind) const {
+    courgette::AssemblyProgram* prog = new courgette::AssemblyProgram();
+    prog->set_image_base(0x00400000);
+
+    courgette::Label* labelA = prog->FindOrMakeAbs32Label(0x00410000);
+    courgette::Label* labelB = prog->FindOrMakeAbs32Label(0x00410004);
+
+    prog->EmitAbs32(labelA);
+    prog->EmitAbs32(labelA);
+    prog->EmitAbs32(labelB);
+    prog->EmitAbs32(labelA);
+    prog->EmitAbs32(labelA);
+    prog->EmitAbs32(labelB);
+
+    if (kind == 0) {
+      labelA->index_ = 0;
+      labelB->index_ = 1;
+    } else {
+      labelA->index_ = 1;
+      labelB->index_ = 0;
+    }
+    prog->AssignRemainingIndexes();
+
+    return prog;
+  }
+
+  courgette::AssemblyProgram* MakeProgramA() const { return MakeProgram(0); }
+  courgette::AssemblyProgram* MakeProgramB() const { return MakeProgram(1); }
+
+  // Returns a string that is the serialized version of |program|.
+  // Deletes |program|.
+  std::string Serialize(courgette::AssemblyProgram *program) const {
+    courgette::EncodedProgram* encoded = NULL;
+
+    const courgette::Status encode_status = Encode(program, &encoded);
+    EXPECT_EQ(courgette::C_OK, encode_status);
+
+    DeleteAssemblyProgram(program);
+
+    courgette::SinkStreamSet sinks;
+    const courgette::Status write_status = WriteEncodedProgram(encoded, &sinks);
+    EXPECT_EQ(courgette::C_OK, write_status);
+
+    DeleteEncodedProgram(encoded);
+
+    courgette::SinkStream sink;
+    bool can_collect = sinks.CopyTo(&sink);
+    EXPECT_TRUE(can_collect);
+
+    return std::string(reinterpret_cast<const char *>(sink.Buffer()),
+                       sink.Length());
+  }
+};
+
+
+void AdjustmentMethodTest::Test1() const {
+  courgette::AssemblyProgram* prog1 = MakeProgramA();
+  courgette::AssemblyProgram* prog2 = MakeProgramB();
+  std::string s1 = Serialize(prog1);
+  std::string s2 = Serialize(prog2);
+
+  // Don't use EXPECT_EQ because strings are unprintable.
+  EXPECT_FALSE(s1 == s2);  // Unadjusted A and B differ.
+
+  courgette::AssemblyProgram* prog5 = MakeProgramA();
+  courgette::AssemblyProgram* prog6 = MakeProgramB();
+  courgette::Status can_adjust = Adjust(*prog5, prog6);
+  EXPECT_EQ(courgette::C_OK, can_adjust);
+  std::string s5 = Serialize(prog5);
+  std::string s6 = Serialize(prog6);
+
+  EXPECT_TRUE(s1 == s5);  // Adjustment did not change A (prog5)
+  EXPECT_TRUE(s5 == s6);  // Adjustment did change B into A
+}
+
+
+TEST_F(AdjustmentMethodTest, All) {
+  Test1();
+}
diff --git a/third_party/courgette/assembly_program.cc b/courgette/assembly_program.cc
index 178dfdf..e40f38f 100644
--- a/third_party/courgette/assembly_program.cc
+++ b/courgette/assembly_program.cc
@@ -1,373 +1,372 @@
-// Copyright (c) 2009 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.

-

-#include "third_party/courgette/assembly_program.h"

-

-#include <memory.h>

-#include <algorithm>

-#include <map>

-#include <set>

-#include <sstream>

-#include <vector>

-

-#include "base/logging.h"

-

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/encoded_program.h"

-

-namespace courgette {

-

-// Opcodes of simple assembly language

-enum OP {

-  ORIGIN,         // ORIGIN <rva> - set current address for assembly.

-  MAKERELOCS,     // Generates a base relocation table.

-  DEFBYTE,        // DEFBYTE <value> - emit a byte literal.

-  REL32,          // REL32 <label> - emit a rel32 encoded reference to 'label'.

-  ABS32,          // REL32 <label> - emit am abs32 encoded reference to 'label'.

-  LAST_OP

-};

-

-// Base class for instructions.  Because we have so many instructions we want to

-// keep them as small as possible.  For this reason we avoid virtual functions.

-//

-class Instruction {

- public:

-  OP op() const { return static_cast<OP>(op_); }

-

- protected:

-  explicit Instruction(OP op) : op_(op), info_(0) {}

-  Instruction(OP op, unsigned int info) : op_(op), info_(info) {}

-

-  uint32 op_   : 4;    // A few bits to store the OP code.

-  uint32 info_ : 28;   // Remaining bits in first word available to subclass.

-

- private:

-  DISALLOW_COPY_AND_ASSIGN(Instruction);

-};

-

-namespace {

-

-// Sets the current address for the emitting instructions.

-class OriginInstruction : public Instruction {

- public:

-  explicit OriginInstruction(RVA rva) : Instruction(ORIGIN, 0), rva_(rva) {}

-  RVA origin_rva() const { return rva_; }

- private:

-  RVA  rva_;

-};

-

-// Emits an entire base relocation table.

-class MakeRelocsInstruction : public Instruction {

- public:

-  MakeRelocsInstruction() : Instruction(MAKERELOCS) {}

-};

-

-// Emits a single byte.

-class ByteInstruction : public Instruction {

- public:

-  explicit ByteInstruction(uint8 value) : Instruction(DEFBYTE, value) {}

-  uint8 byte_value() const { return info_; }

-};

-

-// A ABS32 to REL32 instruction emits a reference to a label's address.

-class InstructionWithLabel : public Instruction {

- public:

-  InstructionWithLabel(OP op, Label* label)

-    : Instruction(op, 0), label_(label) {

-    if (label == NULL) NOTREACHED();

-  }

-  Label* label() const { return label_; }

- private:

-  Label* label_;

-};

-

-}  // namespace

-

-AssemblyProgram::AssemblyProgram()

-  : image_base_(0),

-    byte_instruction_cache_(NULL) {

-}

-

-static void DeleteContainedLabels(const RVAToLabel& labels) {

-  for (RVAToLabel::const_iterator p = labels.begin();  p != labels.end();  ++p)

-    delete p->second;

-}

-

-AssemblyProgram::~AssemblyProgram() {

-  for (size_t i = 0;  i < instructions_.size();  ++i) {

-    Instruction* instruction = instructions_[i];

-    if (instruction->op() != DEFBYTE)  // Will be in byte_instruction_cache_.

-      delete instruction;

-  }

-  if (byte_instruction_cache_) {

-    for (size_t i = 0;  i < 256;  ++i)

-      delete byte_instruction_cache_[i];

-    delete[] byte_instruction_cache_;

-  }

-  DeleteContainedLabels(rel32_labels_);

-  DeleteContainedLabels(abs32_labels_);

-}

-

-void AssemblyProgram::EmitMakeRelocsInstruction() {

-  Emit(new MakeRelocsInstruction());

-}

-

-void AssemblyProgram::EmitOriginInstruction(RVA rva) {

-  Emit(new OriginInstruction(rva));

-}

-

-void AssemblyProgram::EmitByteInstruction(uint8 byte) {

-  Emit(GetByteInstruction(byte));

-}

-

-void AssemblyProgram::EmitRel32(Label* label) {

-  Emit(new InstructionWithLabel(REL32, label));

-}

-

-void AssemblyProgram::EmitAbs32(Label* label) {

-  Emit(new InstructionWithLabel(ABS32, label));

-}

-

-Label* AssemblyProgram::FindOrMakeAbs32Label(RVA rva) {

-  return FindLabel(rva, &abs32_labels_);

-}

-

-Label* AssemblyProgram::FindOrMakeRel32Label(RVA rva) {

-  return FindLabel(rva, &rel32_labels_);

-}

-

-void AssemblyProgram::DefaultAssignIndexes() {

-  DefaultAssignIndexes(&abs32_labels_);

-  DefaultAssignIndexes(&rel32_labels_);

-}

-

-void AssemblyProgram::UnassignIndexes() {

-  UnassignIndexes(&abs32_labels_);

-  UnassignIndexes(&rel32_labels_);

-}

-

-void AssemblyProgram::AssignRemainingIndexes() {

-  AssignRemainingIndexes(&abs32_labels_);

-  AssignRemainingIndexes(&rel32_labels_);

-}

-

-Label* AssemblyProgram::InstructionAbs32Label(

-    const Instruction* instruction) const {

-  if (instruction->op() == ABS32)

-    return static_cast<const InstructionWithLabel*>(instruction)->label();

-  return NULL;

-}

-

-Label* AssemblyProgram::InstructionRel32Label(

-    const Instruction* instruction) const {

-  if (instruction->op() == REL32)

-    return static_cast<const InstructionWithLabel*>(instruction)->label();

-  return NULL;

-}

-

-Label* AssemblyProgram::FindLabel(RVA rva, RVAToLabel* labels) {

-  Label*& slot = (*labels)[rva];

-  if (slot == 0) {

-    slot = new Label(rva);

-  }

-  return slot;

-}

-

-void AssemblyProgram::UnassignIndexes(RVAToLabel* labels) {

-  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {

-    Label* current = p->second;

-    current->index_ = Label::kNoIndex;

-  }

-}

-

-// DefaultAssignIndexes takes a set of labels and assigns indexes in increasing

-// address order.

-//

-void AssemblyProgram::DefaultAssignIndexes(RVAToLabel* labels) {

-  int index = 0;

-  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {

-    Label* current = p->second;

-    if (current->index_ != Label::kNoIndex)

-      NOTREACHED();

-    current->index_ = index;

-    ++index;

-  }

-}

-

-// AssignRemainingIndexes assigns indexes to any addresses (labels) that are not

-// yet assigned an index.

-//

-void AssemblyProgram::AssignRemainingIndexes(RVAToLabel* labels) {

-  // An address table compresses best when each index is associated with an

-  // address that is slight larger than the previous index.

-

-  // First see which indexes have not been used.  The 'available' vector could

-  // grow even bigger, but the number of addresses is a better starting size

-  // than empty.

-  std::vector<bool> available(labels->size(), true);

-  int used = 0;

-

-  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {

-    size_t index = p->second->index_;

-    if (index != Label::kNoIndex) {

-      while (index >= available.size())

-        available.push_back(true);

-      available.at(index) = false;

-      ++used;

-    }

-  }

-

-  LOG(INFO) << used << " of " << labels->size() << " labels pre-assigned";

-

-  // Are there any unused labels that happen to be adjacent following a used

-  // label?

-  //

-  int fill_forward_count = 0;

-  Label* prev = 0;

-  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {

-    Label* current = p->second;

-    if (current->index_ == Label::kNoIndex) {

-      size_t index = 0;

-      if (prev  &&  prev->index_ != Label::kNoIndex)

-        index = prev->index_ + 1;

-      if (index < available.size() && available.at(index)) {

-        current->index_ = index;

-        available.at(index) = false;

-        ++fill_forward_count;

-      }

-    }

-    prev = current;

-  }

-

-  // Are there any unused labels that happen to be adjacent preceeding a used

-  // label?

-  //

-  int fill_backward_count = 0;

-  int backward_refs = 0;

-  prev = 0;

-  for (RVAToLabel::reverse_iterator p = labels->rbegin();

-       p != labels->rend();

-       ++p) {

-    Label* current = p->second;

-    if (current->index_ == Label::kNoIndex) {

-      int prev_index;

-      if (prev)

-        prev_index = prev->index_;

-      else

-        prev_index = available.size();

-      if (prev_index != 0  &&

-          prev_index != Label::kNoIndex  &&

-          available.at(prev_index - 1)) {

-        current->index_ = prev_index - 1;

-        available.at(current->index_) = false;

-        ++fill_backward_count;

-      }

-    }

-    prev = current;

-  }

-

-  // Fill in any remaining indexes

-  int fill_infill_count = 0;

-  int index = 0;

-  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {

-    Label* current = p->second;

-    if (current->index_ == Label::kNoIndex) {

-      while (!available.at(index)) {

-        ++index;

-      }

-      current->index_ = index;

-      available.at(index) = false;

-      ++index;

-      ++fill_infill_count;

-    }

-  }

-

-  LOG(INFO) << "  fill"

-            << " forward " << fill_forward_count << " "

-            << " backward " << fill_backward_count << " "

-            << " infill " << fill_infill_count;

-}

-

-typedef void (EncodedProgram::*DefineLabelMethod)(int index, RVA value);

-

-static void DefineLabels(const RVAToLabel& labels,

-                         EncodedProgram* encoded_format,

-                         DefineLabelMethod define_label) {

-  for (RVAToLabel::const_iterator p = labels.begin(); p != labels.end(); ++p) {

-    Label* label = p->second;

-    (encoded_format->*define_label)(label->index_, label->rva_);

-  }

-}

-

-EncodedProgram* AssemblyProgram::Encode() const {

-  EncodedProgram* encoded = new EncodedProgram();

-

-  encoded->set_image_base(image_base_);

-  DefineLabels(abs32_labels_, encoded, &EncodedProgram::DefineAbs32Label);

-  DefineLabels(rel32_labels_, encoded, &EncodedProgram::DefineRel32Label);

-  encoded->EndLabels();

-

-  for (size_t i = 0;  i < instructions_.size();  ++i) {

-    Instruction* instruction = instructions_[i];

-

-    switch (instruction->op()) {

-      case ORIGIN: {

-        OriginInstruction* org = static_cast<OriginInstruction*>(instruction);

-        encoded->AddOrigin(org->origin_rva());

-        break;

-      }

-      case DEFBYTE: {

-        uint8 b = static_cast<ByteInstruction*>(instruction)->byte_value();

-        encoded->AddCopy(1, &b);

-        break;

-      }

-      case REL32: {

-        Label* label = static_cast<InstructionWithLabel*>(instruction)->label();

-        encoded->AddRel32(label->index_);

-        break;

-      }

-      case ABS32: {

-        Label* label = static_cast<InstructionWithLabel*>(instruction)->label();

-        encoded->AddAbs32(label->index_);

-        break;

-      }

-      case MAKERELOCS: {

-        encoded->AddMakeRelocs();

-        break;

-      }

-      default: {

-        NOTREACHED() << "Unknown Insn OP kind";

-      }

-    }

-  }

-

-  return encoded;

-}

-

-Instruction* AssemblyProgram::GetByteInstruction(uint8 byte) {

-  if (!byte_instruction_cache_) {

-    byte_instruction_cache_ = new Instruction*[256];

-    for (int i = 0; i < 256; ++i) {

-      byte_instruction_cache_[i] = new ByteInstruction(static_cast<uint8>(i));

-    }

-  }

-

-  return byte_instruction_cache_[byte];

-}

-

-////////////////////////////////////////////////////////////////////////////////

-

-Status Encode(AssemblyProgram* program, EncodedProgram** output) {

-  *output = NULL;

-  EncodedProgram *encoded = program->Encode();

-  if (encoded) {

-    *output = encoded;

-    return C_OK;

-  } else {

-    return C_GENERAL_ERROR;

-  }

-}

-

-}  // namespace courgette

-

+// Copyright (c) 2009 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.
+
+#include "courgette/assembly_program.h"
+
+#include <memory.h>
+#include <algorithm>
+#include <map>
+#include <set>
+#include <sstream>
+#include <vector>
+
+#include "base/logging.h"
+
+#include "courgette/courgette.h"
+#include "courgette/encoded_program.h"
+
+namespace courgette {
+
+// Opcodes of simple assembly language
+enum OP {
+  ORIGIN,         // ORIGIN <rva> - set current address for assembly.
+  MAKERELOCS,     // Generates a base relocation table.
+  DEFBYTE,        // DEFBYTE <value> - emit a byte literal.
+  REL32,          // REL32 <label> - emit a rel32 encoded reference to 'label'.
+  ABS32,          // REL32 <label> - emit am abs32 encoded reference to 'label'.
+  LAST_OP
+};
+
+// Base class for instructions.  Because we have so many instructions we want to
+// keep them as small as possible.  For this reason we avoid virtual functions.
+//
+class Instruction {
+ public:
+  OP op() const { return static_cast<OP>(op_); }
+
+ protected:
+  explicit Instruction(OP op) : op_(op), info_(0) {}
+  Instruction(OP op, unsigned int info) : op_(op), info_(info) {}
+
+  uint32 op_   : 4;    // A few bits to store the OP code.
+  uint32 info_ : 28;   // Remaining bits in first word available to subclass.
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Instruction);
+};
+
+namespace {
+
+// Sets the current address for the emitting instructions.
+class OriginInstruction : public Instruction {
+ public:
+  explicit OriginInstruction(RVA rva) : Instruction(ORIGIN, 0), rva_(rva) {}
+  RVA origin_rva() const { return rva_; }
+ private:
+  RVA  rva_;
+};
+
+// Emits an entire base relocation table.
+class MakeRelocsInstruction : public Instruction {
+ public:
+  MakeRelocsInstruction() : Instruction(MAKERELOCS) {}
+};
+
+// Emits a single byte.
+class ByteInstruction : public Instruction {
+ public:
+  explicit ByteInstruction(uint8 value) : Instruction(DEFBYTE, value) {}
+  uint8 byte_value() const { return info_; }
+};
+
+// A ABS32 to REL32 instruction emits a reference to a label's address.
+class InstructionWithLabel : public Instruction {
+ public:
+  InstructionWithLabel(OP op, Label* label)
+    : Instruction(op, 0), label_(label) {
+    if (label == NULL) NOTREACHED();
+  }
+  Label* label() const { return label_; }
+ private:
+  Label* label_;
+};
+
+}  // namespace
+
+AssemblyProgram::AssemblyProgram()
+  : image_base_(0),
+    byte_instruction_cache_(NULL) {
+}
+
+static void DeleteContainedLabels(const RVAToLabel& labels) {
+  for (RVAToLabel::const_iterator p = labels.begin();  p != labels.end();  ++p)
+    delete p->second;
+}
+
+AssemblyProgram::~AssemblyProgram() {
+  for (size_t i = 0;  i < instructions_.size();  ++i) {
+    Instruction* instruction = instructions_[i];
+    if (instruction->op() != DEFBYTE)  // Will be in byte_instruction_cache_.
+      delete instruction;
+  }
+  if (byte_instruction_cache_) {
+    for (size_t i = 0;  i < 256;  ++i)
+      delete byte_instruction_cache_[i];
+    delete[] byte_instruction_cache_;
+  }
+  DeleteContainedLabels(rel32_labels_);
+  DeleteContainedLabels(abs32_labels_);
+}
+
+void AssemblyProgram::EmitMakeRelocsInstruction() {
+  Emit(new MakeRelocsInstruction());
+}
+
+void AssemblyProgram::EmitOriginInstruction(RVA rva) {
+  Emit(new OriginInstruction(rva));
+}
+
+void AssemblyProgram::EmitByteInstruction(uint8 byte) {
+  Emit(GetByteInstruction(byte));
+}
+
+void AssemblyProgram::EmitRel32(Label* label) {
+  Emit(new InstructionWithLabel(REL32, label));
+}
+
+void AssemblyProgram::EmitAbs32(Label* label) {
+  Emit(new InstructionWithLabel(ABS32, label));
+}
+
+Label* AssemblyProgram::FindOrMakeAbs32Label(RVA rva) {
+  return FindLabel(rva, &abs32_labels_);
+}
+
+Label* AssemblyProgram::FindOrMakeRel32Label(RVA rva) {
+  return FindLabel(rva, &rel32_labels_);
+}
+
+void AssemblyProgram::DefaultAssignIndexes() {
+  DefaultAssignIndexes(&abs32_labels_);
+  DefaultAssignIndexes(&rel32_labels_);
+}
+
+void AssemblyProgram::UnassignIndexes() {
+  UnassignIndexes(&abs32_labels_);
+  UnassignIndexes(&rel32_labels_);
+}
+
+void AssemblyProgram::AssignRemainingIndexes() {
+  AssignRemainingIndexes(&abs32_labels_);
+  AssignRemainingIndexes(&rel32_labels_);
+}
+
+Label* AssemblyProgram::InstructionAbs32Label(
+    const Instruction* instruction) const {
+  if (instruction->op() == ABS32)
+    return static_cast<const InstructionWithLabel*>(instruction)->label();
+  return NULL;
+}
+
+Label* AssemblyProgram::InstructionRel32Label(
+    const Instruction* instruction) const {
+  if (instruction->op() == REL32)
+    return static_cast<const InstructionWithLabel*>(instruction)->label();
+  return NULL;
+}
+
+Label* AssemblyProgram::FindLabel(RVA rva, RVAToLabel* labels) {
+  Label*& slot = (*labels)[rva];
+  if (slot == 0) {
+    slot = new Label(rva);
+  }
+  return slot;
+}
+
+void AssemblyProgram::UnassignIndexes(RVAToLabel* labels) {
+  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
+    Label* current = p->second;
+    current->index_ = Label::kNoIndex;
+  }
+}
+
+// DefaultAssignIndexes takes a set of labels and assigns indexes in increasing
+// address order.
+//
+void AssemblyProgram::DefaultAssignIndexes(RVAToLabel* labels) {
+  int index = 0;
+  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
+    Label* current = p->second;
+    if (current->index_ != Label::kNoIndex)
+      NOTREACHED();
+    current->index_ = index;
+    ++index;
+  }
+}
+
+// AssignRemainingIndexes assigns indexes to any addresses (labels) that are not
+// yet assigned an index.
+//
+void AssemblyProgram::AssignRemainingIndexes(RVAToLabel* labels) {
+  // An address table compresses best when each index is associated with an
+  // address that is slight larger than the previous index.
+
+  // First see which indexes have not been used.  The 'available' vector could
+  // grow even bigger, but the number of addresses is a better starting size
+  // than empty.
+  std::vector<bool> available(labels->size(), true);
+  int used = 0;
+
+  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
+    size_t index = p->second->index_;
+    if (index != Label::kNoIndex) {
+      while (index >= available.size())
+        available.push_back(true);
+      available.at(index) = false;
+      ++used;
+    }
+  }
+
+  LOG(INFO) << used << " of " << labels->size() << " labels pre-assigned";
+
+  // Are there any unused labels that happen to be adjacent following a used
+  // label?
+  //
+  int fill_forward_count = 0;
+  Label* prev = 0;
+  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
+    Label* current = p->second;
+    if (current->index_ == Label::kNoIndex) {
+      size_t index = 0;
+      if (prev  &&  prev->index_ != Label::kNoIndex)
+        index = prev->index_ + 1;
+      if (index < available.size() && available.at(index)) {
+        current->index_ = index;
+        available.at(index) = false;
+        ++fill_forward_count;
+      }
+    }
+    prev = current;
+  }
+
+  // Are there any unused labels that happen to be adjacent preceeding a used
+  // label?
+  //
+  int fill_backward_count = 0;
+  int backward_refs = 0;
+  prev = 0;
+  for (RVAToLabel::reverse_iterator p = labels->rbegin();
+       p != labels->rend();
+       ++p) {
+    Label* current = p->second;
+    if (current->index_ == Label::kNoIndex) {
+      int prev_index;
+      if (prev)
+        prev_index = prev->index_;
+      else
+        prev_index = available.size();
+      if (prev_index != 0  &&
+          prev_index != Label::kNoIndex  &&
+          available.at(prev_index - 1)) {
+        current->index_ = prev_index - 1;
+        available.at(current->index_) = false;
+        ++fill_backward_count;
+      }
+    }
+    prev = current;
+  }
+
+  // Fill in any remaining indexes
+  int fill_infill_count = 0;
+  int index = 0;
+  for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
+    Label* current = p->second;
+    if (current->index_ == Label::kNoIndex) {
+      while (!available.at(index)) {
+        ++index;
+      }
+      current->index_ = index;
+      available.at(index) = false;
+      ++index;
+      ++fill_infill_count;
+    }
+  }
+
+  LOG(INFO) << "  fill"
+            << " forward " << fill_forward_count << " "
+            << " backward " << fill_backward_count << " "
+            << " infill " << fill_infill_count;
+}
+
+typedef void (EncodedProgram::*DefineLabelMethod)(int index, RVA value);
+
+static void DefineLabels(const RVAToLabel& labels,
+                         EncodedProgram* encoded_format,
+                         DefineLabelMethod define_label) {
+  for (RVAToLabel::const_iterator p = labels.begin(); p != labels.end(); ++p) {
+    Label* label = p->second;
+    (encoded_format->*define_label)(label->index_, label->rva_);
+  }
+}
+
+EncodedProgram* AssemblyProgram::Encode() const {
+  EncodedProgram* encoded = new EncodedProgram();
+
+  encoded->set_image_base(image_base_);
+  DefineLabels(abs32_labels_, encoded, &EncodedProgram::DefineAbs32Label);
+  DefineLabels(rel32_labels_, encoded, &EncodedProgram::DefineRel32Label);
+  encoded->EndLabels();
+
+  for (size_t i = 0;  i < instructions_.size();  ++i) {
+    Instruction* instruction = instructions_[i];
+
+    switch (instruction->op()) {
+      case ORIGIN: {
+        OriginInstruction* org = static_cast<OriginInstruction*>(instruction);
+        encoded->AddOrigin(org->origin_rva());
+        break;
+      }
+      case DEFBYTE: {
+        uint8 b = static_cast<ByteInstruction*>(instruction)->byte_value();
+        encoded->AddCopy(1, &b);
+        break;
+      }
+      case REL32: {
+        Label* label = static_cast<InstructionWithLabel*>(instruction)->label();
+        encoded->AddRel32(label->index_);
+        break;
+      }
+      case ABS32: {
+        Label* label = static_cast<InstructionWithLabel*>(instruction)->label();
+        encoded->AddAbs32(label->index_);
+        break;
+      }
+      case MAKERELOCS: {
+        encoded->AddMakeRelocs();
+        break;
+      }
+      default: {
+        NOTREACHED() << "Unknown Insn OP kind";
+      }
+    }
+  }
+
+  return encoded;
+}
+
+Instruction* AssemblyProgram::GetByteInstruction(uint8 byte) {
+  if (!byte_instruction_cache_) {
+    byte_instruction_cache_ = new Instruction*[256];
+    for (int i = 0; i < 256; ++i) {
+      byte_instruction_cache_[i] = new ByteInstruction(static_cast<uint8>(i));
+    }
+  }
+
+  return byte_instruction_cache_[byte];
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+Status Encode(AssemblyProgram* program, EncodedProgram** output) {
+  *output = NULL;
+  EncodedProgram *encoded = program->Encode();
+  if (encoded) {
+    *output = encoded;
+    return C_OK;
+  } else {
+    return C_GENERAL_ERROR;
+  }
+}
+
+}  // namespace courgette
diff --git a/third_party/courgette/assembly_program.h b/courgette/assembly_program.h
index 4b48133..e726f81 100644
--- a/third_party/courgette/assembly_program.h
+++ b/courgette/assembly_program.h
@@ -1,134 +1,133 @@
-// Copyright (c) 2009 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.

-

-#ifndef COURGETTE_ASSEMBLY_PROGRAM_H_

-#define COURGETTE_ASSEMBLY_PROGRAM_H_

-

-#include <map>

-#include <set>

-#include <vector>

-

-#include "base/basictypes.h"

-

-#include "third_party/courgette/image_info.h"

-

-namespace courgette {

-

-class EncodedProgram;

-class Instruction;

-

-// A Label is a symbolic reference to an address.  Unlike a conventional

-// assembly language, we always know the address.  The address will later be

-// stored in a table and the Label will be replaced with the index into the

-// table.

-//

-// TODO(sra): Make fields private and add setters and getters.

-class Label {

- public:

-  static const int kNoIndex = -1;

-  Label() : rva_(0), index_(kNoIndex) {}

-  explicit Label(RVA rva) : rva_(rva), index_(kNoIndex) {}

-

-  RVA rva_;    // Address refered to by the label.

-  int index_;  // Index of address in address table, kNoIndex until assigned.

-};

-

-typedef std::map<RVA, Label*> RVAToLabel;

-

-// An AssemblyProgram is the result of disassembling an executable file.

-//

-// * The disassembler creates labels in the AssemblyProgram and emits

-//   'Instructions'.

-// * The disassembler then calls DefaultAssignIndexes to assign

-//   addresses to positions in the address tables.

-// * [Optional step]

-// * At this point the AssemblyProgram can be converted into an

-//   EncodedProgram and serialized to an output stream.

-// * Later, the EncodedProgram can be deserialized and assembled into

-//   the original file.

-//

-// The optional step is to modify the AssemblyProgram.  One form of modification

-// is to assign indexes in such a way as to make the EncodedProgram for this

-// AssemblyProgram look more like the EncodedProgram for some other

-// AssemblyProgram.  The modification process should call UnassignIndexes, do

-// its own assignment, and then call AssignRemainingIndexes to ensure all

-// indexes are assigned.

-//

-class AssemblyProgram {

- public:

-  AssemblyProgram();

-  ~AssemblyProgram();

-

-  void set_image_base(uint64 image_base) { image_base_ = image_base; }

-

-  // Instructions will be assembled in the order they are emitted.

-

-  // Generates an entire base relocation table.

-  void EmitMakeRelocsInstruction();

-

-  // Following instruction will be assembled at address 'rva'.

-  void EmitOriginInstruction(RVA rva);

-

-  // Generates a single byte of data or machine instruction.

-  void EmitByteInstruction(uint8 byte);

-

-  // Generates 4-byte relative reference to address of 'label'.

-  void EmitRel32(Label* label);

-

-  // Generates 4-byte absolute reference to address of 'label'.

-  void EmitAbs32(Label* label);

-

-  Label* FindOrMakeAbs32Label(RVA rva);

-  Label* FindOrMakeRel32Label(RVA rva);

-

-  void DefaultAssignIndexes();

-  void UnassignIndexes();

-  void AssignRemainingIndexes();

-

-  EncodedProgram* Encode() const;

-

-  // Accessor for instruction list.

-  const std::vector<Instruction*>& instructions() const {

-    return instructions_;

-  }

-

-  // Returns the label if the instruction contains and absolute address,

-  // otherwise returns NULL.

-  Label* InstructionAbs32Label(const Instruction* instruction) const;

-

-  // Returns the label if the instruction contains and rel32 offset,

-  // otherwise returns NULL.

-  Label* InstructionRel32Label(const Instruction* instruction) const;

-

-

- private:

-  void Emit(Instruction* instruction) { instructions_.push_back(instruction); }

-

-  Label* FindLabel(RVA rva, RVAToLabel* labels);

-

-  // Helper methods for the public versions.

-  static void UnassignIndexes(RVAToLabel* labels);

-  static void DefaultAssignIndexes(RVAToLabel* labels);

-  static void AssignRemainingIndexes(RVAToLabel* labels);

-

-  // Sharing instructions that emit a single byte saves a lot of space.

-  Instruction* GetByteInstruction(uint8 byte);

-  Instruction** byte_instruction_cache_;

-

-  uint64 image_base_;  // Desired or mandated base address of image.

-

-  std::vector<Instruction*> instructions_;  // All the instructions in program.

-

-  // These are lookup maps to find the label associated with a given address.

-  // We have separate label spaces for addresses referenced by rel32 labels and

-  // abs32 labels.  This is somewhat arbitrary.

-  RVAToLabel rel32_labels_;

-  RVAToLabel abs32_labels_;

-

-  DISALLOW_COPY_AND_ASSIGN(AssemblyProgram);

-};

-

-}  // namespace courgette

-#endif  // COURGETTE_ASSEMBLY_PROGRAM_H_

-

+// Copyright (c) 2009 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.
+
+#ifndef COURGETTE_ASSEMBLY_PROGRAM_H_
+#define COURGETTE_ASSEMBLY_PROGRAM_H_
+
+#include <map>
+#include <set>
+#include <vector>
+
+#include "base/basictypes.h"
+
+#include "courgette/image_info.h"
+
+namespace courgette {
+
+class EncodedProgram;
+class Instruction;
+
+// A Label is a symbolic reference to an address.  Unlike a conventional
+// assembly language, we always know the address.  The address will later be
+// stored in a table and the Label will be replaced with the index into the
+// table.
+//
+// TODO(sra): Make fields private and add setters and getters.
+class Label {
+ public:
+  static const int kNoIndex = -1;
+  Label() : rva_(0), index_(kNoIndex) {}
+  explicit Label(RVA rva) : rva_(rva), index_(kNoIndex) {}
+
+  RVA rva_;    // Address refered to by the label.
+  int index_;  // Index of address in address table, kNoIndex until assigned.
+};
+
+typedef std::map<RVA, Label*> RVAToLabel;
+
+// An AssemblyProgram is the result of disassembling an executable file.
+//
+// * The disassembler creates labels in the AssemblyProgram and emits
+//   'Instructions'.
+// * The disassembler then calls DefaultAssignIndexes to assign
+//   addresses to positions in the address tables.
+// * [Optional step]
+// * At this point the AssemblyProgram can be converted into an
+//   EncodedProgram and serialized to an output stream.
+// * Later, the EncodedProgram can be deserialized and assembled into
+//   the original file.
+//
+// The optional step is to modify the AssemblyProgram.  One form of modification
+// is to assign indexes in such a way as to make the EncodedProgram for this
+// AssemblyProgram look more like the EncodedProgram for some other
+// AssemblyProgram.  The modification process should call UnassignIndexes, do
+// its own assignment, and then call AssignRemainingIndexes to ensure all
+// indexes are assigned.
+//
+class AssemblyProgram {
+ public:
+  AssemblyProgram();
+  ~AssemblyProgram();
+
+  void set_image_base(uint64 image_base) { image_base_ = image_base; }
+
+  // Instructions will be assembled in the order they are emitted.
+
+  // Generates an entire base relocation table.
+  void EmitMakeRelocsInstruction();
+
+  // Following instruction will be assembled at address 'rva'.
+  void EmitOriginInstruction(RVA rva);
+
+  // Generates a single byte of data or machine instruction.
+  void EmitByteInstruction(uint8 byte);
+
+  // Generates 4-byte relative reference to address of 'label'.
+  void EmitRel32(Label* label);
+
+  // Generates 4-byte absolute reference to address of 'label'.
+  void EmitAbs32(Label* label);
+
+  Label* FindOrMakeAbs32Label(RVA rva);
+  Label* FindOrMakeRel32Label(RVA rva);
+
+  void DefaultAssignIndexes();
+  void UnassignIndexes();
+  void AssignRemainingIndexes();
+
+  EncodedProgram* Encode() const;
+
+  // Accessor for instruction list.
+  const std::vector<Instruction*>& instructions() const {
+    return instructions_;
+  }
+
+  // Returns the label if the instruction contains and absolute address,
+  // otherwise returns NULL.
+  Label* InstructionAbs32Label(const Instruction* instruction) const;
+
+  // Returns the label if the instruction contains and rel32 offset,
+  // otherwise returns NULL.
+  Label* InstructionRel32Label(const Instruction* instruction) const;
+
+
+ private:
+  void Emit(Instruction* instruction) { instructions_.push_back(instruction); }
+
+  Label* FindLabel(RVA rva, RVAToLabel* labels);
+
+  // Helper methods for the public versions.
+  static void UnassignIndexes(RVAToLabel* labels);
+  static void DefaultAssignIndexes(RVAToLabel* labels);
+  static void AssignRemainingIndexes(RVAToLabel* labels);
+
+  // Sharing instructions that emit a single byte saves a lot of space.
+  Instruction* GetByteInstruction(uint8 byte);
+  Instruction** byte_instruction_cache_;
+
+  uint64 image_base_;  // Desired or mandated base address of image.
+
+  std::vector<Instruction*> instructions_;  // All the instructions in program.
+
+  // These are lookup maps to find the label associated with a given address.
+  // We have separate label spaces for addresses referenced by rel32 labels and
+  // abs32 labels.  This is somewhat arbitrary.
+  RVAToLabel rel32_labels_;
+  RVAToLabel abs32_labels_;
+
+  DISALLOW_COPY_AND_ASSIGN(AssemblyProgram);
+};
+
+}  // namespace courgette
+#endif  // COURGETTE_ASSEMBLY_PROGRAM_H_
diff --git a/third_party/courgette/bsdiff_memory_unittest.cc b/courgette/bsdiff_memory_unittest.cc
index e1add46..97da726 100644
--- a/third_party/courgette/bsdiff_memory_unittest.cc
+++ b/courgette/bsdiff_memory_unittest.cc
@@ -1,112 +1,111 @@
-// Copyright (c) 2009 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.

-

-#include "third_party/courgette/bsdiff.h"

-

-#include <string>

-

-#include "base/file_util.h"

-#include "base/path_service.h"

-#include "base/string_util.h"

-

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/streams.h"

-

-#include "testing/gtest/include/gtest/gtest.h"

-

-class BSDiffMemoryTest : public testing::Test {

- public:

-  std::string FileContents(const char *file_name) const;

-  void GenerateAndTestPatch(const std::string& a, const std::string& b) const;

-

- private:

-  void SetUp() {

-    PathService::Get(base::DIR_SOURCE_ROOT, &test_dir_);

-    // file_util::AppendToPath(&test_dir_, L"third_party");

-    file_util::AppendToPath(&test_dir_, L"courgette");

-    file_util::AppendToPath(&test_dir_, L"testdata");

-  }

-

-  std::wstring test_dir_;

-};

-

-//  Reads a test file into a string.

-std::string BSDiffMemoryTest::FileContents(const char *file_name) const {

-  std::wstring file_path = test_dir_;

-  file_util::AppendToPath(&file_path, UTF8ToWide(file_name));

-  std::string file_bytes;

-  if (!file_util::ReadFileToString(file_path, &file_bytes)) {

-    EXPECT_TRUE(!"Could not read test data");

-  }

-  return file_bytes;

-}

-

-void BSDiffMemoryTest::GenerateAndTestPatch(const std::string& old_text,

-                                            const std::string& new_text) const {

-  courgette::SourceStream old1;

-  courgette::SourceStream new1;

-  old1.Init(old_text.c_str(), old_text.length());

-  new1.Init(new_text.c_str(), new_text.length());

-

-  courgette::SinkStream patch1;

-  courgette::BSDiffStatus status = CreateBinaryPatch(&old1, &new1, &patch1);

-  EXPECT_EQ(courgette::OK, status);

-

-  courgette::SourceStream old2;

-  courgette::SourceStream patch2;

-  old2.Init(old_text.c_str(), old_text.length());

-  patch2.Init(patch1);

-

-  courgette::SinkStream new2;

-  status = ApplyBinaryPatch(&old2, &patch2, &new2);

-  EXPECT_EQ(courgette::OK, status);

-  EXPECT_EQ(new_text.length(), new2.Length());

-  EXPECT_EQ(0, memcmp(new_text.c_str(), new2.Buffer(), new_text.length()));

-}

-

-TEST_F(BSDiffMemoryTest, TestEmpty) {

-  GenerateAndTestPatch("", "");

-}

-

-TEST_F(BSDiffMemoryTest, TestEmptyVsNonempty) {

-  GenerateAndTestPatch("", "xxx");

-}

-

-TEST_F(BSDiffMemoryTest, TestNonemptyVsEmpty) {

-  GenerateAndTestPatch("xxx", "");

-}

-

-TEST_F(BSDiffMemoryTest, TestSmallInputsWithSmallChanges) {

-  std::string file1 =

-      "I would not, could not, in a box.\n"

-      "I could not, would not, with a fox.\n"

-      "I will not eat them with a mouse.\n"

-      "I will not eat them in a house.\n"

-      "I will not eat them here or there.\n"

-      "I will not eat them anywhere.\n"

-      "I do not eat green eggs and ham.\n"

-      "I do not like them, Sam-I-am.\n";

-  std::string file2 =

-      "I would not, could not, in a BOX.\n"

-      "I could not, would not, with a FOX.\n"

-      "I will not eat them with a MOUSE.\n"

-      "I will not eat them in a HOUSE.\n"

-      "I will not eat them in a HOUSE.\n"     // Extra line.

-      "I will not eat them here or THERE.\n"

-      "I will not eat them ANYWHERE.\n"

-      "I do not eat green eggs and HAM.\n"

-      "I do not like them, Sam-I-am.\n";

-  GenerateAndTestPatch(file1, file2);

-}

-

-TEST_F(BSDiffMemoryTest, TestIndenticalDlls) {

-  std::string file1 = FileContents("en-US.dll");

-  GenerateAndTestPatch(file1, file1);

-}

-

-TEST_F(BSDiffMemoryTest, TestDifferentExes) {

-  std::string file1 = FileContents("setup1.exe");

-  std::string file2 = FileContents("setup2.exe");

-  GenerateAndTestPatch(file1, file2);

-}

+// Copyright (c) 2009 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.
+
+#include "courgette/third_party/bsdiff.h"
+
+#include <string>
+
+#include "base/file_util.h"
+#include "base/path_service.h"
+#include "base/string_util.h"
+
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+class BSDiffMemoryTest : public testing::Test {
+ public:
+  std::string FileContents(const char *file_name) const;
+  void GenerateAndTestPatch(const std::string& a, const std::string& b) const;
+
+ private:
+  void SetUp() {
+    PathService::Get(base::DIR_SOURCE_ROOT, &test_dir_);
+    file_util::AppendToPath(&test_dir_, L"courgette");
+    file_util::AppendToPath(&test_dir_, L"testdata");
+  }
+
+  std::wstring test_dir_;
+};
+
+//  Reads a test file into a string.
+std::string BSDiffMemoryTest::FileContents(const char *file_name) const {
+  std::wstring file_path = test_dir_;
+  file_util::AppendToPath(&file_path, UTF8ToWide(file_name));
+  std::string file_bytes;
+  if (!file_util::ReadFileToString(file_path, &file_bytes)) {
+    EXPECT_TRUE(!"Could not read test data");
+  }
+  return file_bytes;
+}
+
+void BSDiffMemoryTest::GenerateAndTestPatch(const std::string& old_text,
+                                            const std::string& new_text) const {
+  courgette::SourceStream old1;
+  courgette::SourceStream new1;
+  old1.Init(old_text.c_str(), old_text.length());
+  new1.Init(new_text.c_str(), new_text.length());
+
+  courgette::SinkStream patch1;
+  courgette::BSDiffStatus status = CreateBinaryPatch(&old1, &new1, &patch1);
+  EXPECT_EQ(courgette::OK, status);
+
+  courgette::SourceStream old2;
+  courgette::SourceStream patch2;
+  old2.Init(old_text.c_str(), old_text.length());
+  patch2.Init(patch1);
+
+  courgette::SinkStream new2;
+  status = ApplyBinaryPatch(&old2, &patch2, &new2);
+  EXPECT_EQ(courgette::OK, status);
+  EXPECT_EQ(new_text.length(), new2.Length());
+  EXPECT_EQ(0, memcmp(new_text.c_str(), new2.Buffer(), new_text.length()));
+}
+
+TEST_F(BSDiffMemoryTest, TestEmpty) {
+  GenerateAndTestPatch("", "");
+}
+
+TEST_F(BSDiffMemoryTest, TestEmptyVsNonempty) {
+  GenerateAndTestPatch("", "xxx");
+}
+
+TEST_F(BSDiffMemoryTest, TestNonemptyVsEmpty) {
+  GenerateAndTestPatch("xxx", "");
+}
+
+TEST_F(BSDiffMemoryTest, TestSmallInputsWithSmallChanges) {
+  std::string file1 =
+      "I would not, could not, in a box.\n"
+      "I could not, would not, with a fox.\n"
+      "I will not eat them with a mouse.\n"
+      "I will not eat them in a house.\n"
+      "I will not eat them here or there.\n"
+      "I will not eat them anywhere.\n"
+      "I do not eat green eggs and ham.\n"
+      "I do not like them, Sam-I-am.\n";
+  std::string file2 =
+      "I would not, could not, in a BOX.\n"
+      "I could not, would not, with a FOX.\n"
+      "I will not eat them with a MOUSE.\n"
+      "I will not eat them in a HOUSE.\n"
+      "I will not eat them in a HOUSE.\n"     // Extra line.
+      "I will not eat them here or THERE.\n"
+      "I will not eat them ANYWHERE.\n"
+      "I do not eat green eggs and HAM.\n"
+      "I do not like them, Sam-I-am.\n";
+  GenerateAndTestPatch(file1, file2);
+}
+
+TEST_F(BSDiffMemoryTest, TestIndenticalDlls) {
+  std::string file1 = FileContents("en-US.dll");
+  GenerateAndTestPatch(file1, file1);
+}
+
+TEST_F(BSDiffMemoryTest, TestDifferentExes) {
+  std::string file1 = FileContents("setup1.exe");
+  std::string file2 = FileContents("setup2.exe");
+  GenerateAndTestPatch(file1, file2);
+}
diff --git a/third_party/courgette/courgette.gyp b/courgette/courgette.gyp
index a55b191..03de462 100644
--- a/third_party/courgette/courgette.gyp
+++ b/courgette/courgette.gyp
@@ -7,15 +7,15 @@
     'chromium_code': 1,
   },
   'includes': [
-    '../../build/common.gypi',
+    '../build/common.gypi',
   ],
   'targets': [
     {
       'target_name': 'courgette_lib',
       'type': '<(library)',
       'dependencies': [
-        '../../base/base.gyp:base',
-        #'../../third_party/lzma_sdk/7z_C.vcproj',
+        '../base/base.gyp:base',
+        #'../third_party/lzma_sdk/7z_C.vcproj',
       ],
       'msvs_guid': '9A72A362-E617-4205-B9F2-43C6FB280FA1',
       'sources': [
@@ -23,9 +23,9 @@
         'adjustment_method.h',
         'assembly_program.cc',
         'assembly_program.h',
-        'bsdiff.h',
-        'bsdiff_apply.cc',
-        'bsdiff_create.cc',
+        'third_party/bsdiff.h',
+        'third_party/bsdiff_apply.cc',
+        'third_party/bsdiff_create.cc',
         'courgette.h',
         'crc.cc',
         'crc.h',
@@ -49,38 +49,29 @@
         'win32_x86_generator.h',
         'win32_x86_patcher.h',
       ],
-      'include_dirs': [
-        #'..',
-      ],
-      'direct_dependent_settings': {
-        'include_dirs': [
-         # '..',
-        ],
-      },
     },
-    {
-      'target_name': 'courgette_tool',
+   {
+      'target_name': 'courgette',
       'type': 'executable',
       'msvs_guid': '4EA8CE12-9C6F-45E5-9D08-720383FE3685',
       'sources': [
         'courgette_tool.cc',
-        #'memory_monitor.cc',
-      ],
+       ],
       'dependencies': [
         'courgette_lib',
-        '../../base/base.gyp:base',
+        '../base/base.gyp:base',
       ],
     },
-    {
+   {
       'target_name': 'courgette_minimal_tool',
       'type': 'executable',
       'msvs_guid': 'EB79415F-2F17-4BDC-AADD-4CA4C2D21B73',
       'sources': [
         'courgette_minimal_tool.cc',
-      ],
+       ],
       'dependencies': [
         'courgette_lib',
-        '../../base/base.gyp:base',
+        '../base/base.gyp:base',
       ],
     },
     {
@@ -96,24 +87,24 @@
         'image_info_unittest.cc',
         'run_all_unittests.cc',
         'streams_unittest.cc',
-      ],
+       ],
       'dependencies': [
         'courgette_lib',
-        '../../base/base.gyp:base',
-        '../../testing/gtest.gyp:gtest',
+        '../base/base.gyp:base',
+        '../testing/gtest.gyp:gtest',
       ],
     },
-    {
+   {
       'target_name': 'courgette_fuzz',
       'type': 'executable',
       'msvs_guid': '57C27529-8CA9-4FC3-9C02-DA05B172F785',
       'sources': [
         'encoded_program_fuzz_unittest.cc',
-      ],
+       ],
       'dependencies': [
         'courgette_lib',
-        '../../base/base.gyp:base',
-        '../../testing/gtest.gyp:gtest',
+        '../base/base.gyp:base',
+        '../testing/gtest.gyp:gtest',
       ],
     },
   ],
diff --git a/third_party/courgette/courgette.h b/courgette/courgette.h
index 09bb375..0ddded5 100644
--- a/third_party/courgette/courgette.h
+++ b/courgette/courgette.h
@@ -1,118 +1,118 @@
-// Copyright (c) 2009 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.

-

-#ifndef COURGETTE_COURGETTE_H_

-#define COURGETTE_COURGETTE_H_

-

-namespace courgette {

-

-// Status codes for Courgette APIs.

-//

-// Client code should only rely on the distintion between C_OK and the other

-// status codes.

-//

-enum Status {

-  C_OK = 1,                       // Successful operation.

-

-  C_GENERAL_ERROR = 2,            // Error other than listed below.

-

-  C_READ_OPEN_ERROR = 3,          // Could not open input file for reading.

-  C_READ_ERROR = 4,               // Could not read from opened input file.

-

-  C_WRITE_OPEN_ERROR = 3,         // Could not open output file for writing.

-  C_WRITE_ERROR = 4,              // Could not write to opened output file.

-

-  C_BAD_ENSEMBLE_MAGIC = 5,       // Ensemble patch has bad magic.

-  C_BAD_ENSEMBLE_VERSION = 6,     // Ensemble patch has wrong version.

-  C_BAD_ENSEMBLE_HEADER = 7,      // Ensemble patch has corrupt header.

-  C_BAD_ENSEMBLE_CRC = 8,         // Ensemble patch has corrupt header.

-

-  C_BAD_TRANSFORM = 12,           // Transform mis-specified.

-  C_BAD_BASE = 13,                // Base for transform malformed.

-

-  C_BINARY_DIFF_CRC_ERROR = 14,   // Internal diff input doesn't have expected

-                                  // CRC.

-

-  // Internal errors.

-  C_STREAM_ERROR = 20,            // Unexpected error from streams.h.

-  C_STREAM_NOT_CONSUMED = 21,     // Stream has extra data, is expected to be

-                                  // used up.

-  C_SERIALIZATION_FAILED = 22,    //

-  C_DESERIALIZATION_FAILED = 23,  //

-  C_INPUT_NOT_RECOGNIZED = 24,    // Unrecognized input (not an executable).

-  C_DISASSEMBLY_FAILED = 25,      //

-  C_ASSEMBLY_FAILED = 26,         //

-  C_ADJUSTMENT_FAILED = 27,       //

-

-

-};

-

-class SinkStream;

-class SinkStreamSet;

-class SourceStream;

-class SourceStreamSet;

-

-class AssemblyProgram;

-class EncodedProgram;

-

-// Applies the patch to the bytes in |old| and writes the transformed ensemble

-// to |output|.

-// Returns C_OK unless something went wrong.

-Status ApplyEnsemblePatch(SourceStream* old, SourceStream* patch,

-                          SinkStream* output);

-

-// Applies the patch in |patch_file_name| to the bytes in |old_file_name| and

-// writes the transformed ensemble to |new_file_name|.

-// Returns C_OK unless something went wrong.

-// This function first validates that the patch file has a proper header, so the

-// function can be used to 'try' a patch.

-Status ApplyEnsemblePatch(const wchar_t* old_file_name,

-                          const wchar_t* patch_file_name,

-                          const wchar_t* new_file_name);

-

-// Generates a patch that will transform the bytes in |old| into the bytes in

-// |target|.

-// Returns C_OK unless something when wrong (unexpected).

-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|.

-// 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);

-

-// Converts |program| into encoded form, returning it as |*output|.

-// Returns C_OK if succeeded, otherwise returns an error status and

-// sets |*output| to NULL

-Status Encode(AssemblyProgram* program, EncodedProgram** output);

-

-

-// Serializes |encoded| into the stream set.

-// Returns C_OK if succeeded, otherwise returns an error status.

-Status WriteEncodedProgram(EncodedProgram* encoded, SinkStreamSet* sink);

-

-// Assembles |encoded|, emitting the bytes into |buffer|.

-// Returns C_OK if succeeded, otherwise returns an error status and leaves

-// |buffer| in an undefined state.

-Status Assemble(EncodedProgram* encoded, SinkStream* buffer);

-

-// Deserializes program from the stream set.

-// Returns C_OK if succeeded, otherwise returns an error status and

-// sets |*output| to NULL

-Status ReadEncodedProgram(SourceStreamSet* source, EncodedProgram** output);

-

-// Used to free an AssemblyProgram returned by other APIs.

-void DeleteAssemblyProgram(AssemblyProgram* program);

-

-// Used to free an EncodedProgram returned by other APIs.

-void DeleteEncodedProgram(EncodedProgram* encoded);

-

-// Adjusts |program| to look more like |model|.

-//

-Status Adjust(const AssemblyProgram& model, AssemblyProgram *program);

-

-}  // namespace courgette

-#endif  // COURGETTE_COURGETTE_H_

+// Copyright (c) 2009 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.
+
+#ifndef COURGETTE_COURGETTE_H_
+#define COURGETTE_COURGETTE_H_
+
+namespace courgette {
+
+// Status codes for Courgette APIs.
+//
+// Client code should only rely on the distintion between C_OK and the other
+// status codes.
+//
+enum Status {
+  C_OK = 1,                       // Successful operation.
+
+  C_GENERAL_ERROR = 2,            // Error other than listed below.
+
+  C_READ_OPEN_ERROR = 3,          // Could not open input file for reading.
+  C_READ_ERROR = 4,               // Could not read from opened input file.
+
+  C_WRITE_OPEN_ERROR = 3,         // Could not open output file for writing.
+  C_WRITE_ERROR = 4,              // Could not write to opened output file.
+
+  C_BAD_ENSEMBLE_MAGIC = 5,       // Ensemble patch has bad magic.
+  C_BAD_ENSEMBLE_VERSION = 6,     // Ensemble patch has wrong version.
+  C_BAD_ENSEMBLE_HEADER = 7,      // Ensemble patch has corrupt header.
+  C_BAD_ENSEMBLE_CRC = 8,         // Ensemble patch has corrupt header.
+
+  C_BAD_TRANSFORM = 12,           // Transform mis-specified.
+  C_BAD_BASE = 13,                // Base for transform malformed.
+
+  C_BINARY_DIFF_CRC_ERROR = 14,   // Internal diff input doesn't have expected
+                                  // CRC.
+
+  // Internal errors.
+  C_STREAM_ERROR = 20,            // Unexpected error from streams.h.
+  C_STREAM_NOT_CONSUMED = 21,     // Stream has extra data, is expected to be
+                                  // used up.
+  C_SERIALIZATION_FAILED = 22,    //
+  C_DESERIALIZATION_FAILED = 23,  //
+  C_INPUT_NOT_RECOGNIZED = 24,    // Unrecognized input (not an executable).
+  C_DISASSEMBLY_FAILED = 25,      //
+  C_ASSEMBLY_FAILED = 26,         //
+  C_ADJUSTMENT_FAILED = 27,       //
+
+
+};
+
+class SinkStream;
+class SinkStreamSet;
+class SourceStream;
+class SourceStreamSet;
+
+class AssemblyProgram;
+class EncodedProgram;
+
+// Applies the patch to the bytes in |old| and writes the transformed ensemble
+// to |output|.
+// Returns C_OK unless something went wrong.
+Status ApplyEnsemblePatch(SourceStream* old, SourceStream* patch,
+                          SinkStream* output);
+
+// Applies the patch in |patch_file_name| to the bytes in |old_file_name| and
+// writes the transformed ensemble to |new_file_name|.
+// Returns C_OK unless something went wrong.
+// This function first validates that the patch file has a proper header, so the
+// function can be used to 'try' a patch.
+Status ApplyEnsemblePatch(const wchar_t* old_file_name,
+                          const wchar_t* patch_file_name,
+                          const wchar_t* new_file_name);
+
+// Generates a patch that will transform the bytes in |old| into the bytes in
+// |target|.
+// Returns C_OK unless something when wrong (unexpected).
+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|.
+// 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);
+
+// Converts |program| into encoded form, returning it as |*output|.
+// Returns C_OK if succeeded, otherwise returns an error status and
+// sets |*output| to NULL
+Status Encode(AssemblyProgram* program, EncodedProgram** output);
+
+
+// Serializes |encoded| into the stream set.
+// Returns C_OK if succeeded, otherwise returns an error status.
+Status WriteEncodedProgram(EncodedProgram* encoded, SinkStreamSet* sink);
+
+// Assembles |encoded|, emitting the bytes into |buffer|.
+// Returns C_OK if succeeded, otherwise returns an error status and leaves
+// |buffer| in an undefined state.
+Status Assemble(EncodedProgram* encoded, SinkStream* buffer);
+
+// Deserializes program from the stream set.
+// Returns C_OK if succeeded, otherwise returns an error status and
+// sets |*output| to NULL
+Status ReadEncodedProgram(SourceStreamSet* source, EncodedProgram** output);
+
+// Used to free an AssemblyProgram returned by other APIs.
+void DeleteAssemblyProgram(AssemblyProgram* program);
+
+// Used to free an EncodedProgram returned by other APIs.
+void DeleteEncodedProgram(EncodedProgram* encoded);
+
+// Adjusts |program| to look more like |model|.
+//
+Status Adjust(const AssemblyProgram& model, AssemblyProgram *program);
+
+}  // namespace courgette
+#endif  // COURGETTE_COURGETTE_H_
diff --git a/courgette/courgette.sln b/courgette/courgette.sln
new file mode 100644
index 0000000..38e1f59
--- /dev/null
+++ b/courgette/courgette.sln
@@ -0,0 +1,111 @@
+Microsoft Visual Studio Solution File, Format Version 9.00

+# Visual Studio 2005

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_lib", "courgette_lib.vcproj", "{9A72A362-E617-4205-B9F2-43C6FB280FA1}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_unittests", "courgette_unittests.vcproj", "{24309F1A-4035-46F9-A3D8-F47DC4BCC2B8}"

+	ProjectSection(ProjectDependencies) = postProject

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1} = {9A72A362-E617-4205-B9F2-43C6FB280FA1}

+		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}

+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B} = {BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {F22022F0-2D3B-5610-4E80-C674A8E01C5A}

+		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_fuzz", "courgette_fuzz.vcproj", "{57C27529-8CA9-4FC3-9C02-DA05B172F785}"

+	ProjectSection(ProjectDependencies) = postProject

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1} = {9A72A362-E617-4205-B9F2-43C6FB280FA1}

+		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}

+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B} = {BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {F22022F0-2D3B-5610-4E80-C674A8E01C5A}

+		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette_minimal_tool", "courgette_minimal_tool.vcproj", "{EB79415F-2F17-4BDC-AADD-4CA4C2D21B73}"

+	ProjectSection(ProjectDependencies) = postProject

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1} = {9A72A362-E617-4205-B9F2-43C6FB280FA1}

+		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {F22022F0-2D3B-5610-4E80-C674A8E01C5A}

+		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "courgette", "courgette.vcproj", "{4EA8CE12-9C6F-45E5-9D08-720383FE3685}"

+	ProjectSection(ProjectDependencies) = postProject

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1} = {9A72A362-E617-4205-B9F2-43C6FB280FA1}

+		{1832A374-8A74-4F9E-B536-69A699B3E165} = {1832A374-8A74-4F9E-B536-69A699B3E165}

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {F22022F0-2D3B-5610-4E80-C674A8E01C5A}

+		{8C27D792-2648-4F5E-9ED0-374276327308} = {8C27D792-2648-4F5E-9ED0-374276327308}

+	EndProjectSection

+EndProject

+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "dependencies", "dependencies", "{3C050794-ECB2-85EB-D650-18D00BF2A989}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "icuuc", "..\third_party\icu38\icuuc.vcproj", "{8C27D792-2648-4F5E-9ED0-374276327308}"

+	ProjectSection(ProjectDependencies) = postProject

+		{A0D94973-D355-47A5-A1E2-3456F321F010} = {A0D94973-D355-47A5-A1E2-3456F321F010}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "icui18n", "..\third_party\icu38\icui18n.vcproj", "{F22022F0-2D3B-5610-4E80-C674A8E01C5A}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "icudata", "..\third_party\icu38\icudata.vcproj", "{A0D94973-D355-47A5-A1E2-3456F321F010}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "base", "..\base\base.vcproj", "{1832A374-8A74-4F9E-B536-69A699B3E165}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest", "..\testing\gtest.vcproj", "{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}"

+EndProject

+Global

+	GlobalSection(SolutionConfigurationPlatforms) = preSolution

+		Debug|Win32 = Debug|Win32

+		Release|Win32 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ProjectConfigurationPlatforms) = postSolution

+		{1832A374-8A74-4F9E-B536-69A699B3E165}.Debug|Win32.ActiveCfg = Debug|Win32

+		{1832A374-8A74-4F9E-B536-69A699B3E165}.Debug|Win32.Build.0 = Debug|Win32

+		{1832A374-8A74-4F9E-B536-69A699B3E165}.Release|Win32.ActiveCfg = Release|Win32

+		{1832A374-8A74-4F9E-B536-69A699B3E165}.Release|Win32.Build.0 = Release|Win32

+		{24309F1A-4035-46F9-A3D8-F47DC4BCC2B8}.Debug|Win32.ActiveCfg = Debug|Win32

+		{24309F1A-4035-46F9-A3D8-F47DC4BCC2B8}.Debug|Win32.Build.0 = Debug|Win32

+		{24309F1A-4035-46F9-A3D8-F47DC4BCC2B8}.Release|Win32.ActiveCfg = Release|Win32

+		{24309F1A-4035-46F9-A3D8-F47DC4BCC2B8}.Release|Win32.Build.0 = Release|Win32

+		{4EA8CE12-9C6F-45E5-9D08-720383FE3685}.Debug|Win32.ActiveCfg = Debug|Win32

+		{4EA8CE12-9C6F-45E5-9D08-720383FE3685}.Debug|Win32.Build.0 = Debug|Win32

+		{4EA8CE12-9C6F-45E5-9D08-720383FE3685}.Release|Win32.ActiveCfg = Release|Win32

+		{4EA8CE12-9C6F-45E5-9D08-720383FE3685}.Release|Win32.Build.0 = Release|Win32

+		{57C27529-8CA9-4FC3-9C02-DA05B172F785}.Debug|Win32.ActiveCfg = Debug|Win32

+		{57C27529-8CA9-4FC3-9C02-DA05B172F785}.Debug|Win32.Build.0 = Debug|Win32

+		{57C27529-8CA9-4FC3-9C02-DA05B172F785}.Release|Win32.ActiveCfg = Release|Win32

+		{57C27529-8CA9-4FC3-9C02-DA05B172F785}.Release|Win32.Build.0 = Release|Win32

+		{8C27D792-2648-4F5E-9ED0-374276327308}.Debug|Win32.ActiveCfg = Debug|Win32

+		{8C27D792-2648-4F5E-9ED0-374276327308}.Debug|Win32.Build.0 = Debug|Win32

+		{8C27D792-2648-4F5E-9ED0-374276327308}.Release|Win32.ActiveCfg = Release|Win32

+		{8C27D792-2648-4F5E-9ED0-374276327308}.Release|Win32.Build.0 = Release|Win32

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1}.Debug|Win32.ActiveCfg = Debug|Win32

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1}.Debug|Win32.Build.0 = Debug|Win32

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1}.Release|Win32.ActiveCfg = Release|Win32

+		{9A72A362-E617-4205-B9F2-43C6FB280FA1}.Release|Win32.Build.0 = Release|Win32

+		{A0D94973-D355-47A5-A1E2-3456F321F010}.Debug|Win32.ActiveCfg = Debug|Win32

+		{A0D94973-D355-47A5-A1E2-3456F321F010}.Debug|Win32.Build.0 = Debug|Win32

+		{A0D94973-D355-47A5-A1E2-3456F321F010}.Release|Win32.ActiveCfg = Release|Win32

+		{A0D94973-D355-47A5-A1E2-3456F321F010}.Release|Win32.Build.0 = Release|Win32

+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Debug|Win32.ActiveCfg = Debug|Win32

+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Debug|Win32.Build.0 = Debug|Win32

+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Release|Win32.ActiveCfg = Release|Win32

+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B}.Release|Win32.Build.0 = Release|Win32

+		{EB79415F-2F17-4BDC-AADD-4CA4C2D21B73}.Debug|Win32.ActiveCfg = Debug|Win32

+		{EB79415F-2F17-4BDC-AADD-4CA4C2D21B73}.Debug|Win32.Build.0 = Debug|Win32

+		{EB79415F-2F17-4BDC-AADD-4CA4C2D21B73}.Release|Win32.ActiveCfg = Release|Win32

+		{EB79415F-2F17-4BDC-AADD-4CA4C2D21B73}.Release|Win32.Build.0 = Release|Win32

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A}.Debug|Win32.ActiveCfg = Debug|Win32

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A}.Debug|Win32.Build.0 = Debug|Win32

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A}.Release|Win32.ActiveCfg = Release|Win32

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A}.Release|Win32.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(SolutionProperties) = preSolution

+		HideSolutionNode = FALSE

+	EndGlobalSection

+	GlobalSection(NestedProjects) = preSolution

+		{8C27D792-2648-4F5E-9ED0-374276327308} = {3C050794-ECB2-85EB-D650-18D00BF2A989}

+		{F22022F0-2D3B-5610-4E80-C674A8E01C5A} = {3C050794-ECB2-85EB-D650-18D00BF2A989}

+		{A0D94973-D355-47A5-A1E2-3456F321F010} = {3C050794-ECB2-85EB-D650-18D00BF2A989}

+		{1832A374-8A74-4F9E-B536-69A699B3E165} = {3C050794-ECB2-85EB-D650-18D00BF2A989}

+		{BFE8E2A7-3B3B-43B0-A994-3058B852DB8B} = {3C050794-ECB2-85EB-D650-18D00BF2A989}

+	EndGlobalSection

+EndGlobal

diff --git a/third_party/courgette/courgette_minimal_tool.cc b/courgette/courgette_minimal_tool.cc
index de5cd9e..84de068 100644
--- a/third_party/courgette/courgette_minimal_tool.cc
+++ b/courgette/courgette_minimal_tool.cc
@@ -1,50 +1,50 @@
-// Copyright (c) 2009 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.

-

-// 'courgette_minimal_tool' is not meant to be a serious command-line tool.  It

-// has the minimum logic to apply a Courgette patch to a file.  The main purpose

-// is to monitor the code size of the patcher.

-

-#include <string>

-

-#include "base/file_util.h"

-

-#include "third_party/courgette/bsdiff.h"

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/streams.h"

-

-void PrintHelp() {

-  fprintf(stderr,

-    "Usage:\n"

-    "  courgette_minimal_tool <old-file-input> <patch-file-input>"

-    " <new-file-output>\n"

-    "\n");

-}

-

-void UsageProblem(const char* message) {

-  fprintf(stderr, "%s\n", message);

-  PrintHelp();

-  exit(1);

-}

-

-void Problem(const char* message) {

-  fprintf(stderr, "%s\n", message);

-  exit(1);

-}

-

-int wmain(int argc, const wchar_t* argv[]) {

-  if (argc != 4)

-    UsageProblem("bad args");

-

-  courgette::Status status =

-      courgette::ApplyEnsemblePatch(argv[1], argv[2], argv[3]);

-

-  if (status != courgette::C_OK) {

-    if (status == courgette::C_READ_OPEN_ERROR) Problem("Can't open file.");

-    if (status == courgette::C_WRITE_OPEN_ERROR) Problem("Can't open file.");

-    if (status == courgette::C_READ_ERROR) Problem("Can't read from file.");

-    if (status == courgette::C_WRITE_ERROR) Problem("Can't write to file.");

-    Problem("patch failed.");

-  }

-}

+// Copyright (c) 2009 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.
+
+// 'courgette_minimal_tool' is not meant to be a serious command-line tool.  It
+// has the minimum logic to apply a Courgette patch to a file.  The main purpose
+// is to monitor the code size of the patcher.
+
+#include <string>
+
+#include "base/file_util.h"
+
+#include "courgette/third_party/bsdiff.h"
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
+
+void PrintHelp() {
+  fprintf(stderr,
+    "Usage:\n"
+    "  courgette_minimal_tool <old-file-input> <patch-file-input>"
+    " <new-file-output>\n"
+    "\n");
+}
+
+void UsageProblem(const char* message) {
+  fprintf(stderr, "%s\n", message);
+  PrintHelp();
+  exit(1);
+}
+
+void Problem(const char* message) {
+  fprintf(stderr, "%s\n", message);
+  exit(1);
+}
+
+int wmain(int argc, const wchar_t* argv[]) {
+  if (argc != 4)
+    UsageProblem("bad args");
+
+  courgette::Status status =
+      courgette::ApplyEnsemblePatch(argv[1], argv[2], argv[3]);
+
+  if (status != courgette::C_OK) {
+    if (status == courgette::C_READ_OPEN_ERROR) Problem("Can't open file.");
+    if (status == courgette::C_WRITE_OPEN_ERROR) Problem("Can't open file.");
+    if (status == courgette::C_READ_ERROR) Problem("Can't read from file.");
+    if (status == courgette::C_WRITE_ERROR) Problem("Can't write to file.");
+    Problem("patch failed.");
+  }
+}
diff --git a/third_party/courgette/courgette_tool.cc b/courgette/courgette_tool.cc
index 867101a7..c07f2da 100644
--- a/third_party/courgette/courgette_tool.cc
+++ b/courgette/courgette_tool.cc
@@ -1,405 +1,404 @@
-// Copyright (c) 2009 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.

-

-#include <vector>

-#include <string>

-

-#include "base/at_exit.h"

-#include "base/basictypes.h"

-#include "base/command_line.h"

-#include "base/file_util.h"

-#include "base/logging.h"

-#include "base/string_util.h"

-

-#include "third_party/courgette/bsdiff.h"

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/streams.h"

-

-

-void PrintHelp() {

-  fprintf(stderr,

-    "Usage:\n"

-    "  courgette_tool -dis <executable_file> <binary_assembly_file>\n"

-    "  courgette_tool -asm <binary_assembly_file> <executable_file>\n"

-    "  courgette_tool -disadj "

-          "<executable_file> <reference> <binary_assembly_file>\n"

-    "  courgette_tool -gen <v1> <v2> <patch>\n"

-    "  courgette_tool -apply <v1> <patch> <v2>\n"

-    "\n");

-}

-

-void UsageProblem(const char* message) {

-  fprintf(stderr, "%s", message);

-  fprintf(stderr, "\n");

-  PrintHelp();

-  exit(1);

-}

-

-void Problem(const char* format, ...) {

-  va_list args;

-  va_start(args, format);

-  vfprintf(stderr, format, args);

-  fprintf(stderr, "\n");

-  va_end(args);

-  exit(1);

-}

-

-std::string ReadOrFail(const std::wstring& file_name, const char* kind) {

-  FilePath file_path(file_name);

-  std::string buffer;

-  if (!file_util::ReadFileToString(file_path, &buffer))

-    Problem("Can't read %s file.", kind);

-  return buffer;

-}

-

-void WriteSinkToFile(const courgette::SinkStream *sink,

-                     const std::wstring& output_file) {

-  FilePath output_path(output_file);

-  int count =

-      file_util::WriteFile(output_path,

-                           reinterpret_cast<const char*>(sink->Buffer()),

-                           sink->Length());

-  if (count == -1)

-    Problem("Cant write output.");

-  if (count != sink->Length())

-    Problem("Incomplete write.");

-}

-

-void Disassemble(const std::wstring& input_file,

-                 const std::wstring& output_file) {

-  std::string buffer = ReadOrFail(input_file, "input");

-

-  courgette::AssemblyProgram* program = NULL;

-  const courgette::Status parse_status =

-      courgette::ParseWin32X86PE(buffer.c_str(), buffer.length(), &program);

-

-  if (parse_status != courgette::C_OK)

-    Problem("Can't parse input.");

-

-  courgette::EncodedProgram* encoded = NULL;

-  const courgette::Status encode_status = Encode(program, &encoded);

-

-  courgette::DeleteAssemblyProgram(program);

-

-  if (encode_status != courgette::C_OK)

-    Problem("Can't encode program.");

-

-  courgette::SinkStreamSet sinks;

-

-  const courgette::Status write_status =

-    courgette::WriteEncodedProgram(encoded, &sinks);

-  if (write_status != courgette::C_OK)

-    Problem("Can't serialize encoded program.");

-

-  courgette::DeleteEncodedProgram(encoded);

-

-  courgette::SinkStream sink;

-  sinks.CopyTo(&sink);

-

-  WriteSinkToFile(&sink, output_file);

-}

-

-void DisassembleAndAdjust(const std::wstring& program_file,

-                          const std::wstring& model_file,

-                          const std::wstring& output_file) {

-  std::string program_buffer = ReadOrFail(program_file, "program");

-  std::string model_buffer = ReadOrFail(model_file, "reference");

-

-  courgette::AssemblyProgram* program = NULL;

-  const courgette::Status parse_program_status =

-      courgette::ParseWin32X86PE(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);

-  if (parse_model_status != courgette::C_OK)

-    Problem("Can't parse model input.");

-

-  const courgette::Status adjust_status = Adjust(*model, program);

-  if (adjust_status != courgette::C_OK)

-    Problem("Can't adjust program.");

-

-  courgette::EncodedProgram* encoded = NULL;

-  const courgette::Status encode_status = Encode(program, &encoded);

-

-  courgette::DeleteAssemblyProgram(program);

-

-  if (encode_status != courgette::C_OK)

-    Problem("Can't encode program.");

-

-  courgette::SinkStreamSet sinks;

-

-  const courgette::Status write_status =

-    courgette::WriteEncodedProgram(encoded, &sinks);

-  if (write_status != courgette::C_OK)

-    Problem("Can't serialize encoded program.");

-

-  courgette::DeleteEncodedProgram(encoded);

-

-  courgette::SinkStream sink;

-  sinks.CopyTo(&sink);

-

-  WriteSinkToFile(&sink, output_file);

-}

-

-// Diffs two executable files, write a set of files for the diff, one file per

-// stream of the EncodedProgram format.  Each file is the bsdiff between the

-// original file's stream and the new file's stream.  This is completely

-// uninteresting to users, but it is handy for seeing how much each which

-// streams are contributing to the final file size.  Adjustment is optional.

-void DisassembleAdjustDiff(const std::wstring& model_file,

-                           const std::wstring& program_file,

-                           const std::wstring& output_file_root,

-                           bool adjust) {

-  std::string model_buffer = ReadOrFail(model_file, "'old'");

-  std::string program_buffer = ReadOrFail(program_file, "'new'");

-

-  courgette::AssemblyProgram* model = NULL;

-  const courgette::Status parse_model_status =

-      courgette::ParseWin32X86PE(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);

-  if (parse_program_status != courgette::C_OK)

-    Problem("Can't parse program input.");

-

-  if (adjust) {

-    const courgette::Status adjust_status = Adjust(*model, program);

-    if (adjust_status != courgette::C_OK)

-      Problem("Can't adjust program.");

-  }

-

-  courgette::EncodedProgram* encoded_program = NULL;

-  const courgette::Status encode_program_status =

-      Encode(program, &encoded_program);

-  courgette::DeleteAssemblyProgram(program);

-  if (encode_program_status != courgette::C_OK)

-    Problem("Can't encode program.");

-

-  courgette::EncodedProgram* encoded_model = NULL;

-  const courgette::Status encode_model_status = Encode(model, &encoded_model);

-  courgette::DeleteAssemblyProgram(model);

-  if (encode_model_status != courgette::C_OK)

-    Problem("Can't encode model.");

-

-  courgette::SinkStreamSet program_sinks;

-  const courgette::Status write_program_status =

-    courgette::WriteEncodedProgram(encoded_program, &program_sinks);

-  if (write_program_status != courgette::C_OK)

-    Problem("Can't serialize encoded program.");

-  courgette::DeleteEncodedProgram(encoded_program);

-

-  courgette::SinkStreamSet model_sinks;

-  const courgette::Status write_model_status =

-    courgette::WriteEncodedProgram(encoded_model, &model_sinks);

-  if (write_model_status != courgette::C_OK)

-    Problem("Can't serialize encoded model.");

-  courgette::DeleteEncodedProgram(encoded_program);

-

-  for (int i = 0;  ; ++i) {

-    courgette::SinkStream* old_stream = model_sinks.stream(i);

-    courgette::SinkStream* new_stream = program_sinks.stream(i);

-    if (old_stream == NULL  && new_stream == NULL)

-      break;

-

-    courgette::SourceStream old_source;

-    courgette::SourceStream new_source;

-    old_source.Init(*old_stream);

-    new_source.Init(*new_stream);

-    courgette::SinkStream patch_stream;

-    courgette::BSDiffStatus status =

-        courgette::CreateBinaryPatch(&old_source, &new_source, &patch_stream);

-    if (status != courgette::OK) Problem("-xxx failed.");

-

-    WriteSinkToFile(&patch_stream,

-                    output_file_root + L"-" + IntToWString(i));

-  }

-}

-

-void Assemble(const std::wstring& input_file,

-              const std::wstring& output_file) {

-  std::string buffer = ReadOrFail(input_file, "input");

-

-  courgette::SourceStreamSet sources;

-  if (!sources.Init(buffer.c_str(), buffer.length()))

-    Problem("Bad input file.");

-

-  courgette::EncodedProgram* encoded = NULL;

-  const courgette::Status read_status = ReadEncodedProgram(&sources, &encoded);

-  if (read_status != courgette::C_OK)

-    Problem("Bad encoded program.");

-

-  courgette::SinkStream sink;

-

-  const courgette::Status assemble_status = courgette::Assemble(encoded, &sink);

-  if (assemble_status != courgette::C_OK)

-    Problem("Can't assemble.");

-

-  WriteSinkToFile(&sink, output_file);

-}

-

-void GenerateEnsemblePatch(const std::wstring& old_file,

-                           const std::wstring& new_file,

-                           const std::wstring& patch_file) {

-  std::string old_buffer = ReadOrFail(old_file, "'old' input");

-  std::string new_buffer = ReadOrFail(new_file, "'new' input");

-

-  courgette::SourceStream old_stream;

-  courgette::SourceStream new_stream;

-  old_stream.Init(old_buffer);

-  new_stream.Init(new_buffer);

-

-  courgette::SinkStream patch_stream;

-  courgette::Status status =

-      courgette::GenerateEnsemblePatch(&old_stream, &new_stream, &patch_stream);

-

-  if (status != courgette::C_OK) Problem("-gen failed.");

-

-  WriteSinkToFile(&patch_stream, patch_file);

-}

-

-void ApplyEnsemblePatch(const std::wstring& old_file,

-                        const std::wstring& patch_file,

-                        const std::wstring& new_file) {

-  std::string old_buffer = ReadOrFail(old_file, "'old' input");

-  std::string patch_buffer = ReadOrFail(patch_file, "'patch' input");

-

-  courgette::SourceStream old_stream;

-  courgette::SourceStream patch_stream;

-  old_stream.Init(old_buffer);

-  patch_stream.Init(patch_buffer);

-  courgette::SinkStream new_stream;

-  courgette::Status status =

-      courgette::ApplyEnsemblePatch(&old_stream, &patch_stream, &new_stream);

-

-  if (status != courgette::C_OK) Problem("-apply failed.");

-

-  WriteSinkToFile(&new_stream, new_file);

-}

-

-void GenerateBSDiffPatch(const std::wstring& old_file,

-                         const std::wstring& new_file,

-                         const std::wstring& patch_file) {

-  std::string old_buffer = ReadOrFail(old_file, "'old' input");

-  std::string new_buffer = ReadOrFail(new_file, "'new' input");

-

-  courgette::SourceStream old_stream;

-  courgette::SourceStream new_stream;

-  old_stream.Init(old_buffer);

-  new_stream.Init(new_buffer);

-

-  courgette::SinkStream patch_stream;

-  courgette::BSDiffStatus status =

-      courgette::CreateBinaryPatch(&old_stream, &new_stream, &patch_stream);

-

-  if (status != courgette::OK) Problem("-genbsdiff failed.");

-

-  WriteSinkToFile(&patch_stream, patch_file);

-}

-

-void ApplyBSDiffPatch(const std::wstring& old_file,

-                      const std::wstring& patch_file,

-                      const std::wstring& new_file) {

-  std::string old_buffer = ReadOrFail(old_file, "'old' input");

-  std::string patch_buffer = ReadOrFail(patch_file, "'patch' input");

-

-  courgette::SourceStream old_stream;

-  courgette::SourceStream patch_stream;

-  old_stream.Init(old_buffer);

-  patch_stream.Init(patch_buffer);

-

-  courgette::SinkStream new_stream;

-  courgette::BSDiffStatus status =

-      courgette::ApplyBinaryPatch(&old_stream, &patch_stream, &new_stream);

-

-  if (status != courgette::OK) Problem("-applybsdiff failed.");

-

-  WriteSinkToFile(&new_stream, new_file);

-}

-

-int main(int argc, const char* argv[]) {

-  base::AtExitManager at_exit_manager;

-  CommandLine::Init(argc, argv);

-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();

-

-  bool cmd_dis = command_line.HasSwitch(L"dis");

-  bool cmd_asm = command_line.HasSwitch(L"asm");

-  bool cmd_disadj = command_line.HasSwitch(L"disadj");

-  bool cmd_make_patch = command_line.HasSwitch(L"gen");

-  bool cmd_apply_patch = command_line.HasSwitch(L"apply");

-  bool cmd_make_bsdiff_patch = command_line.HasSwitch(L"genbsdiff");

-  bool cmd_apply_bsdiff_patch = command_line.HasSwitch(L"applybsdiff");

-  bool cmd_spread_1_adjusted = command_line.HasSwitch(L"gen1a");

-  bool cmd_spread_1_unadjusted = command_line.HasSwitch(L"gen1u");

-

-  std::vector<std::wstring> values = command_line.GetLooseValues();

-

-  // '-repeat=N' is for debugging.  Running many iterations can reveal leaks and

-  // bugs in cleanup.

-  int repeat_count = 1;

-  std::wstring repeat_switch = command_line.GetSwitchValue(L"repeat");

-  if (!repeat_switch.empty())

-    if (!StringToInt(repeat_switch, &repeat_count))

-      repeat_count = 1;

-

-  if (cmd_dis + cmd_asm + cmd_disadj + cmd_make_patch + cmd_apply_patch +

-      cmd_make_bsdiff_patch + cmd_apply_bsdiff_patch +

-      cmd_spread_1_adjusted + cmd_spread_1_unadjusted

-      != 1)

-    UsageProblem(

-        "Must have exactly one of:\n"

-        "  -asm, -dis, -disadj, -gen or -apply, -genbsdiff or -applybsdiff.");

-

-  while (repeat_count-- > 0) {

-    if (cmd_dis) {

-      if (values.size() != 2)

-        UsageProblem("-dis <executable_file> <courgette_file>");

-      Disassemble(values[0], values[1]);

-    } else if (cmd_asm) {

-      if (values.size() != 2)

-        UsageProblem("-asm <courgette_file_input> <executable_file_output>");

-      Assemble(values[0], values[1]);

-    } else if (cmd_disadj) {

-      if (values.size() != 3)

-        UsageProblem("-disadj <executable_file> <model> <courgette_file>");

-      DisassembleAndAdjust(values[0], values[1], values[2]);

-    } else if (cmd_make_patch) {

-      if (values.size() != 3)

-        UsageProblem("-gen <old_file> <new_file> <patch_file>");

-      GenerateEnsemblePatch(values[0], values[1], values[2]);

-    } else if (cmd_apply_patch) {

-      if (values.size() != 3)

-        UsageProblem("-apply <old_file> <patch_file> <new_file>");

-      ApplyEnsemblePatch(values[0], values[1], values[2]);

-    } else if (cmd_make_bsdiff_patch) {

-      if (values.size() != 3)

-        UsageProblem("-genbsdiff <old_file> <new_file> <patch_file>");

-      GenerateBSDiffPatch(values[0], values[1], values[2]);

-    } else if (cmd_apply_bsdiff_patch) {

-      if (values.size() != 3)

-        UsageProblem("-applybsdiff <old_file> <patch_file> <new_file>");

-      ApplyBSDiffPatch(values[0], values[1], values[2]);

-    } else if (cmd_spread_1_adjusted || cmd_spread_1_unadjusted) {

-      if (values.size() != 3)

-        UsageProblem("-gen1[au] <old_file> <new_file> <patch_files_root>");

-      DisassembleAdjustDiff(values[0], values[1], values[2],

-                            cmd_spread_1_adjusted);

-    } else {

-      UsageProblem("No operation specified");

-    }

-  }

-}

+// Copyright (c) 2009 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.
+
+#include <vector>
+#include <string>
+
+#include "base/at_exit.h"
+#include "base/basictypes.h"
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+
+#include "courgette/third_party/bsdiff.h"
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
+
+
+void PrintHelp() {
+  fprintf(stderr,
+    "Usage:\n"
+    "  courgette -dis <executable_file> <binary_assembly_file>\n"
+    "  courgette -asm <binary_assembly_file> <executable_file>\n"
+    "  courgette -disadj <executable_file> <reference> <binary_assembly_file>\n"
+    "  courgette -gen <v1> <v2> <patch>\n"
+    "  courgette -apply <v1> <patch> <v2>\n"
+    "\n");
+}
+
+void UsageProblem(const char* message) {
+  fprintf(stderr, "%s", message);
+  fprintf(stderr, "\n");
+  PrintHelp();
+  exit(1);
+}
+
+void Problem(const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  vfprintf(stderr, format, args);
+  fprintf(stderr, "\n");
+  va_end(args);
+  exit(1);
+}
+
+std::string ReadOrFail(const std::wstring& file_name, const char* kind) {
+  FilePath file_path(file_name);
+  std::string buffer;
+  if (!file_util::ReadFileToString(file_path, &buffer))
+    Problem("Can't read %s file.", kind);
+  return buffer;
+}
+
+void WriteSinkToFile(const courgette::SinkStream *sink,
+                     const std::wstring& output_file) {
+  FilePath output_path(output_file);
+  int count =
+      file_util::WriteFile(output_path,
+                           reinterpret_cast<const char*>(sink->Buffer()),
+                           sink->Length());
+  if (count == -1)
+    Problem("Cant write output.");
+  if (count != sink->Length())
+    Problem("Incomplete write.");
+}
+
+void Disassemble(const std::wstring& input_file,
+                 const std::wstring& output_file) {
+  std::string buffer = ReadOrFail(input_file, "input");
+
+  courgette::AssemblyProgram* program = NULL;
+  const courgette::Status parse_status =
+      courgette::ParseWin32X86PE(buffer.c_str(), buffer.length(), &program);
+
+  if (parse_status != courgette::C_OK)
+    Problem("Can't parse input.");
+
+  courgette::EncodedProgram* encoded = NULL;
+  const courgette::Status encode_status = Encode(program, &encoded);
+
+  courgette::DeleteAssemblyProgram(program);
+
+  if (encode_status != courgette::C_OK)
+    Problem("Can't encode program.");
+
+  courgette::SinkStreamSet sinks;
+
+  const courgette::Status write_status =
+    courgette::WriteEncodedProgram(encoded, &sinks);
+  if (write_status != courgette::C_OK)
+    Problem("Can't serialize encoded program.");
+
+  courgette::DeleteEncodedProgram(encoded);
+
+  courgette::SinkStream sink;
+  sinks.CopyTo(&sink);
+
+  WriteSinkToFile(&sink, output_file);
+}
+
+void DisassembleAndAdjust(const std::wstring& program_file,
+                          const std::wstring& model_file,
+                          const std::wstring& output_file) {
+  std::string program_buffer = ReadOrFail(program_file, "program");
+  std::string model_buffer = ReadOrFail(model_file, "reference");
+
+  courgette::AssemblyProgram* program = NULL;
+  const courgette::Status parse_program_status =
+      courgette::ParseWin32X86PE(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);
+  if (parse_model_status != courgette::C_OK)
+    Problem("Can't parse model input.");
+
+  const courgette::Status adjust_status = Adjust(*model, program);
+  if (adjust_status != courgette::C_OK)
+    Problem("Can't adjust program.");
+
+  courgette::EncodedProgram* encoded = NULL;
+  const courgette::Status encode_status = Encode(program, &encoded);
+
+  courgette::DeleteAssemblyProgram(program);
+
+  if (encode_status != courgette::C_OK)
+    Problem("Can't encode program.");
+
+  courgette::SinkStreamSet sinks;
+
+  const courgette::Status write_status =
+    courgette::WriteEncodedProgram(encoded, &sinks);
+  if (write_status != courgette::C_OK)
+    Problem("Can't serialize encoded program.");
+
+  courgette::DeleteEncodedProgram(encoded);
+
+  courgette::SinkStream sink;
+  sinks.CopyTo(&sink);
+
+  WriteSinkToFile(&sink, output_file);
+}
+
+// Diffs two executable files, write a set of files for the diff, one file per
+// stream of the EncodedProgram format.  Each file is the bsdiff between the
+// original file's stream and the new file's stream.  This is completely
+// uninteresting to users, but it is handy for seeing how much each which
+// streams are contributing to the final file size.  Adjustment is optional.
+void DisassembleAdjustDiff(const std::wstring& model_file,
+                           const std::wstring& program_file,
+                           const std::wstring& output_file_root,
+                           bool adjust) {
+  std::string model_buffer = ReadOrFail(model_file, "'old'");
+  std::string program_buffer = ReadOrFail(program_file, "'new'");
+
+  courgette::AssemblyProgram* model = NULL;
+  const courgette::Status parse_model_status =
+      courgette::ParseWin32X86PE(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);
+  if (parse_program_status != courgette::C_OK)
+    Problem("Can't parse program input.");
+
+  if (adjust) {
+    const courgette::Status adjust_status = Adjust(*model, program);
+    if (adjust_status != courgette::C_OK)
+      Problem("Can't adjust program.");
+  }
+
+  courgette::EncodedProgram* encoded_program = NULL;
+  const courgette::Status encode_program_status =
+      Encode(program, &encoded_program);
+  courgette::DeleteAssemblyProgram(program);
+  if (encode_program_status != courgette::C_OK)
+    Problem("Can't encode program.");
+
+  courgette::EncodedProgram* encoded_model = NULL;
+  const courgette::Status encode_model_status = Encode(model, &encoded_model);
+  courgette::DeleteAssemblyProgram(model);
+  if (encode_model_status != courgette::C_OK)
+    Problem("Can't encode model.");
+
+  courgette::SinkStreamSet program_sinks;
+  const courgette::Status write_program_status =
+    courgette::WriteEncodedProgram(encoded_program, &program_sinks);
+  if (write_program_status != courgette::C_OK)
+    Problem("Can't serialize encoded program.");
+  courgette::DeleteEncodedProgram(encoded_program);
+
+  courgette::SinkStreamSet model_sinks;
+  const courgette::Status write_model_status =
+    courgette::WriteEncodedProgram(encoded_model, &model_sinks);
+  if (write_model_status != courgette::C_OK)
+    Problem("Can't serialize encoded model.");
+  courgette::DeleteEncodedProgram(encoded_program);
+
+  for (int i = 0;  ; ++i) {
+    courgette::SinkStream* old_stream = model_sinks.stream(i);
+    courgette::SinkStream* new_stream = program_sinks.stream(i);
+    if (old_stream == NULL  && new_stream == NULL)
+      break;
+
+    courgette::SourceStream old_source;
+    courgette::SourceStream new_source;
+    old_source.Init(*old_stream);
+    new_source.Init(*new_stream);
+    courgette::SinkStream patch_stream;
+    courgette::BSDiffStatus status =
+        courgette::CreateBinaryPatch(&old_source, &new_source, &patch_stream);
+    if (status != courgette::OK) Problem("-xxx failed.");
+
+    WriteSinkToFile(&patch_stream,
+                    output_file_root + L"-" + IntToWString(i));
+  }
+}
+
+void Assemble(const std::wstring& input_file,
+              const std::wstring& output_file) {
+  std::string buffer = ReadOrFail(input_file, "input");
+
+  courgette::SourceStreamSet sources;
+  if (!sources.Init(buffer.c_str(), buffer.length()))
+    Problem("Bad input file.");
+
+  courgette::EncodedProgram* encoded = NULL;
+  const courgette::Status read_status = ReadEncodedProgram(&sources, &encoded);
+  if (read_status != courgette::C_OK)
+    Problem("Bad encoded program.");
+
+  courgette::SinkStream sink;
+
+  const courgette::Status assemble_status = courgette::Assemble(encoded, &sink);
+  if (assemble_status != courgette::C_OK)
+    Problem("Can't assemble.");
+
+  WriteSinkToFile(&sink, output_file);
+}
+
+void GenerateEnsemblePatch(const std::wstring& old_file,
+                           const std::wstring& new_file,
+                           const std::wstring& patch_file) {
+  std::string old_buffer = ReadOrFail(old_file, "'old' input");
+  std::string new_buffer = ReadOrFail(new_file, "'new' input");
+
+  courgette::SourceStream old_stream;
+  courgette::SourceStream new_stream;
+  old_stream.Init(old_buffer);
+  new_stream.Init(new_buffer);
+
+  courgette::SinkStream patch_stream;
+  courgette::Status status =
+      courgette::GenerateEnsemblePatch(&old_stream, &new_stream, &patch_stream);
+
+  if (status != courgette::C_OK) Problem("-gen failed.");
+
+  WriteSinkToFile(&patch_stream, patch_file);
+}
+
+void ApplyEnsemblePatch(const std::wstring& old_file,
+                        const std::wstring& patch_file,
+                        const std::wstring& new_file) {
+  std::string old_buffer = ReadOrFail(old_file, "'old' input");
+  std::string patch_buffer = ReadOrFail(patch_file, "'patch' input");
+
+  courgette::SourceStream old_stream;
+  courgette::SourceStream patch_stream;
+  old_stream.Init(old_buffer);
+  patch_stream.Init(patch_buffer);
+  courgette::SinkStream new_stream;
+  courgette::Status status =
+      courgette::ApplyEnsemblePatch(&old_stream, &patch_stream, &new_stream);
+
+  if (status != courgette::C_OK) Problem("-apply failed.");
+
+  WriteSinkToFile(&new_stream, new_file);
+}
+
+void GenerateBSDiffPatch(const std::wstring& old_file,
+                         const std::wstring& new_file,
+                         const std::wstring& patch_file) {
+  std::string old_buffer = ReadOrFail(old_file, "'old' input");
+  std::string new_buffer = ReadOrFail(new_file, "'new' input");
+
+  courgette::SourceStream old_stream;
+  courgette::SourceStream new_stream;
+  old_stream.Init(old_buffer);
+  new_stream.Init(new_buffer);
+
+  courgette::SinkStream patch_stream;
+  courgette::BSDiffStatus status =
+      courgette::CreateBinaryPatch(&old_stream, &new_stream, &patch_stream);
+
+  if (status != courgette::OK) Problem("-genbsdiff failed.");
+
+  WriteSinkToFile(&patch_stream, patch_file);
+}
+
+void ApplyBSDiffPatch(const std::wstring& old_file,
+                      const std::wstring& patch_file,
+                      const std::wstring& new_file) {
+  std::string old_buffer = ReadOrFail(old_file, "'old' input");
+  std::string patch_buffer = ReadOrFail(patch_file, "'patch' input");
+
+  courgette::SourceStream old_stream;
+  courgette::SourceStream patch_stream;
+  old_stream.Init(old_buffer);
+  patch_stream.Init(patch_buffer);
+
+  courgette::SinkStream new_stream;
+  courgette::BSDiffStatus status =
+      courgette::ApplyBinaryPatch(&old_stream, &patch_stream, &new_stream);
+
+  if (status != courgette::OK) Problem("-applybsdiff failed.");
+
+  WriteSinkToFile(&new_stream, new_file);
+}
+
+int main(int argc, const char* argv[]) {
+  base::AtExitManager at_exit_manager;
+  CommandLine::Init(argc, argv);
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+
+  bool cmd_dis = command_line.HasSwitch(L"dis");
+  bool cmd_asm = command_line.HasSwitch(L"asm");
+  bool cmd_disadj = command_line.HasSwitch(L"disadj");
+  bool cmd_make_patch = command_line.HasSwitch(L"gen");
+  bool cmd_apply_patch = command_line.HasSwitch(L"apply");
+  bool cmd_make_bsdiff_patch = command_line.HasSwitch(L"genbsdiff");
+  bool cmd_apply_bsdiff_patch = command_line.HasSwitch(L"applybsdiff");
+  bool cmd_spread_1_adjusted = command_line.HasSwitch(L"gen1a");
+  bool cmd_spread_1_unadjusted = command_line.HasSwitch(L"gen1u");
+
+  std::vector<std::wstring> values = command_line.GetLooseValues();
+
+  // '-repeat=N' is for debugging.  Running many iterations can reveal leaks and
+  // bugs in cleanup.
+  int repeat_count = 1;
+  std::wstring repeat_switch = command_line.GetSwitchValue(L"repeat");
+  if (!repeat_switch.empty())
+    if (!StringToInt(repeat_switch, &repeat_count))
+      repeat_count = 1;
+
+  if (cmd_dis + cmd_asm + cmd_disadj + cmd_make_patch + cmd_apply_patch +
+      cmd_make_bsdiff_patch + cmd_apply_bsdiff_patch +
+      cmd_spread_1_adjusted + cmd_spread_1_unadjusted
+      != 1)
+    UsageProblem(
+        "Must have exactly one of:\n"
+        "  -asm, -dis, -disadj, -gen or -apply, -genbsdiff or -applybsdiff.");
+
+  while (repeat_count-- > 0) {
+    if (cmd_dis) {
+      if (values.size() != 2)
+        UsageProblem("-dis <executable_file> <courgette_file>");
+      Disassemble(values[0], values[1]);
+    } else if (cmd_asm) {
+      if (values.size() != 2)
+        UsageProblem("-asm <courgette_file_input> <executable_file_output>");
+      Assemble(values[0], values[1]);
+    } else if (cmd_disadj) {
+      if (values.size() != 3)
+        UsageProblem("-disadj <executable_file> <model> <courgette_file>");
+      DisassembleAndAdjust(values[0], values[1], values[2]);
+    } else if (cmd_make_patch) {
+      if (values.size() != 3)
+        UsageProblem("-gen <old_file> <new_file> <patch_file>");
+      GenerateEnsemblePatch(values[0], values[1], values[2]);
+    } else if (cmd_apply_patch) {
+      if (values.size() != 3)
+        UsageProblem("-apply <old_file> <patch_file> <new_file>");
+      ApplyEnsemblePatch(values[0], values[1], values[2]);
+    } else if (cmd_make_bsdiff_patch) {
+      if (values.size() != 3)
+        UsageProblem("-genbsdiff <old_file> <new_file> <patch_file>");
+      GenerateBSDiffPatch(values[0], values[1], values[2]);
+    } else if (cmd_apply_bsdiff_patch) {
+      if (values.size() != 3)
+        UsageProblem("-applybsdiff <old_file> <patch_file> <new_file>");
+      ApplyBSDiffPatch(values[0], values[1], values[2]);
+    } else if (cmd_spread_1_adjusted || cmd_spread_1_unadjusted) {
+      if (values.size() != 3)
+        UsageProblem("-gen1[au] <old_file> <new_file> <patch_files_root>");
+      DisassembleAdjustDiff(values[0], values[1], values[2],
+                            cmd_spread_1_adjusted);
+    } else {
+      UsageProblem("No operation specified");
+    }
+  }
+}
diff --git a/third_party/courgette/crc.cc b/courgette/crc.cc
index 6bf51fe..60c8c93 100644
--- a/third_party/courgette/crc.cc
+++ b/courgette/crc.cc
@@ -1,22 +1,22 @@
-// Copyright (c) 2009 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.

-

-// Calculate Crc by calling CRC method in LZMA SDK

-

-#include "third_party/courgette/crc.h"

-

-extern "C" {

-#include "third_party/lzma_sdk/7zCrc.h"

-}

-

-namespace courgette {

-

-uint32 CalculateCrc(const uint8* buffer, size_t size) {

-  // CrcGenerateTable();

-  uint32 crc = 0xffffffffL;

-  // crc = ~CrcCalc(buffer, size);

-  return crc;

-}

-

-}  // namespace

+// Copyright (c) 2009 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.
+
+// Calculate Crc by calling CRC method in LZMA SDK
+
+#include "courgette/crc.h"
+
+extern "C" {
+#include "third_party/lzma_sdk/7zCrc.h"
+}
+
+namespace courgette {
+
+uint32 CalculateCrc(const uint8* buffer, size_t size) {
+  // CrcGenerateTable();
+  uint32 crc = 0xffffffffL;
+  // crc = ~CrcCalc(buffer, size);
+  return crc;
+}
+
+}  // namespace
diff --git a/third_party/courgette/crc.h b/courgette/crc.h
index 6f4fbb0..c3662bb 100644
--- a/third_party/courgette/crc.h
+++ b/courgette/crc.h
@@ -1,17 +1,17 @@
-// Copyright (c) 2009 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.

-

-#ifndef COURGETTE_CRC_H_

-#define COURGETTE_CRC_H_

-

-#include "base/basictypes.h"

-

-namespace courgette {

-

-// Calculates Crc of the given buffer by calling CRC method in LZMA SDK

-//

-uint32 CalculateCrc(const uint8* buffer, size_t size);

-

-}  // namespace courgette

-#endif  // COURGETTE_CRC_H_

+// Copyright (c) 2009 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.
+
+#ifndef COURGETTE_CRC_H_
+#define COURGETTE_CRC_H_
+
+#include "base/basictypes.h"
+
+namespace courgette {
+
+// Calculates Crc of the given buffer by calling CRC method in LZMA SDK
+//
+uint32 CalculateCrc(const uint8* buffer, size_t size);
+
+}  // namespace courgette
+#endif  // COURGETTE_CRC_H_
diff --git a/third_party/courgette/difference_estimator.cc b/courgette/difference_estimator.cc
index 943eafb..e591f9b 100644
--- a/third_party/courgette/difference_estimator.cc
+++ b/courgette/difference_estimator.cc
@@ -1,118 +1,118 @@
-// Copyright (c) 2009 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.

-

-// We want to measure the similarity of two sequences of bytes as a surrogate

-// for measuring how well a second sequence will compress differentially to the

-// first sequence.

-

-#include "third_party/courgette/difference_estimator.h"

-

-#include "base/hash_tables.h"

-

-namespace courgette {

-

-// Our difference measure is the number of k-tuples that occur in Subject that

-// don't occur in Base.

-const int kTupleSize = 4;

-

-namespace {

-

-COMPILE_ASSERT(kTupleSize >= 4 && kTupleSize <= 8, kTupleSize_between_4_and_8);

-

-size_t HashTuple(const uint8* source) {

-  size_t hash1 = *reinterpret_cast<const uint32*>(source);

-  size_t hash2 = *reinterpret_cast<const uint32*>(source + kTupleSize - 4);

-  size_t hash = ((hash1 * 17 + hash2 * 37) + (hash1 >> 17)) ^ (hash2 >> 23);

-  return hash;

-}

-

-bool RegionsEqual(const Region& a, const Region& b) {

-  if (a.length() != b.length())

-    return false;

-  return memcmp(a.start(), b.start(), a.length()) == 0;

-}

-

-}  // anonymous namepace

-

-class DifferenceEstimator::Base {

- public:

-  explicit Base(const Region& region) : region_(region) { }

-

-  void Init() {

-    const uint8* start = region_.start();

-    const uint8* end = region_.end() - (kTupleSize - 1);

-    for (const uint8* p = start;  p < end;  ++p) {

-      size_t hash = HashTuple(p);

-      hashes_.insert(hash);

-    }

-  }

-

-  const Region& region() const { return region_; }

-

- private:

-  Region region_;

-  base::hash_set<size_t> hashes_;

-

-  friend class DifferenceEstimator;

-  DISALLOW_COPY_AND_ASSIGN(Base);

-};

-

-class DifferenceEstimator::Subject {

- public:

-  explicit Subject(const Region& region) : region_(region) {}

-

-  const Region& region() const { return region_; }

-

- private:

-  Region region_;

-

-  DISALLOW_COPY_AND_ASSIGN(Subject);

-};

-

-DifferenceEstimator::DifferenceEstimator() {}

-

-DifferenceEstimator::~DifferenceEstimator() {

-  for (size_t i = 0;  i < owned_bases_.size();  ++i)

-    delete owned_bases_[i];

-  for (size_t i = 0;  i < owned_subjects_.size();  ++i)

-    delete owned_subjects_[i];

-}

-

-DifferenceEstimator::Base* DifferenceEstimator::MakeBase(const Region& region) {

-  Base* base = new Base(region);

-  base->Init();

-  owned_bases_.push_back(base);

-  return base;

-}

-

-DifferenceEstimator::Subject* DifferenceEstimator::MakeSubject(

-    const Region& region) {

-  Subject* subject = new Subject(region);

-  owned_subjects_.push_back(subject);

-  return subject;

-}

-

-size_t DifferenceEstimator::Measure(Base* base, Subject* subject) {

-  size_t mismatches = 0;

-  const uint8* start = subject->region().start();

-  const uint8* end = subject->region().end() - (kTupleSize - 1);

-

-  const uint8* p = start;

-  while (p < end) {

-    size_t hash = HashTuple(p);

-    if (base->hashes_.find(hash) == base->hashes_.end()) {

-      ++mismatches;

-    }

-    p += 1;

-  }

-

-  if (mismatches == 0) {

-    if (RegionsEqual(base->region(), subject->region()))

-      return 0;

-  }

-  ++mismatches;  // Guarantee not zero.

-  return mismatches;

-}

-

-}  // namespace

+// Copyright (c) 2009 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.
+
+// We want to measure the similarity of two sequences of bytes as a surrogate
+// for measuring how well a second sequence will compress differentially to the
+// first sequence.
+
+#include "courgette/difference_estimator.h"
+
+#include "base/hash_tables.h"
+
+namespace courgette {
+
+// Our difference measure is the number of k-tuples that occur in Subject that
+// don't occur in Base.
+const int kTupleSize = 4;
+
+namespace {
+
+COMPILE_ASSERT(kTupleSize >= 4 && kTupleSize <= 8, kTupleSize_between_4_and_8);
+
+size_t HashTuple(const uint8* source) {
+  size_t hash1 = *reinterpret_cast<const uint32*>(source);
+  size_t hash2 = *reinterpret_cast<const uint32*>(source + kTupleSize - 4);
+  size_t hash = ((hash1 * 17 + hash2 * 37) + (hash1 >> 17)) ^ (hash2 >> 23);
+  return hash;
+}
+
+bool RegionsEqual(const Region& a, const Region& b) {
+  if (a.length() != b.length())
+    return false;
+  return memcmp(a.start(), b.start(), a.length()) == 0;
+}
+
+}  // anonymous namepace
+
+class DifferenceEstimator::Base {
+ public:
+  explicit Base(const Region& region) : region_(region) { }
+
+  void Init() {
+    const uint8* start = region_.start();
+    const uint8* end = region_.end() - (kTupleSize - 1);
+    for (const uint8* p = start;  p < end;  ++p) {
+      size_t hash = HashTuple(p);
+      hashes_.insert(hash);
+    }
+  }
+
+  const Region& region() const { return region_; }
+
+ private:
+  Region region_;
+  base::hash_set<size_t> hashes_;
+
+  friend class DifferenceEstimator;
+  DISALLOW_COPY_AND_ASSIGN(Base);
+};
+
+class DifferenceEstimator::Subject {
+ public:
+  explicit Subject(const Region& region) : region_(region) {}
+
+  const Region& region() const { return region_; }
+
+ private:
+  Region region_;
+
+  DISALLOW_COPY_AND_ASSIGN(Subject);
+};
+
+DifferenceEstimator::DifferenceEstimator() {}
+
+DifferenceEstimator::~DifferenceEstimator() {
+  for (size_t i = 0;  i < owned_bases_.size();  ++i)
+    delete owned_bases_[i];
+  for (size_t i = 0;  i < owned_subjects_.size();  ++i)
+    delete owned_subjects_[i];
+}
+
+DifferenceEstimator::Base* DifferenceEstimator::MakeBase(const Region& region) {
+  Base* base = new Base(region);
+  base->Init();
+  owned_bases_.push_back(base);
+  return base;
+}
+
+DifferenceEstimator::Subject* DifferenceEstimator::MakeSubject(
+    const Region& region) {
+  Subject* subject = new Subject(region);
+  owned_subjects_.push_back(subject);
+  return subject;
+}
+
+size_t DifferenceEstimator::Measure(Base* base, Subject* subject) {
+  size_t mismatches = 0;
+  const uint8* start = subject->region().start();
+  const uint8* end = subject->region().end() - (kTupleSize - 1);
+
+  const uint8* p = start;
+  while (p < end) {
+    size_t hash = HashTuple(p);
+    if (base->hashes_.find(hash) == base->hashes_.end()) {
+      ++mismatches;
+    }
+    p += 1;
+  }
+
+  if (mismatches == 0) {
+    if (RegionsEqual(base->region(), subject->region()))
+      return 0;
+  }
+  ++mismatches;  // Guarantee not zero.
+  return mismatches;
+}
+
+}  // namespace
diff --git a/third_party/courgette/difference_estimator.h b/courgette/difference_estimator.h
index bd550ec..295ff93 100644
--- a/third_party/courgette/difference_estimator.h
+++ b/courgette/difference_estimator.h
@@ -1,58 +1,58 @@
-// Copyright (c) 2009 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.

-

-// A DifferenceEstimator class provides a means for quickly estimating the

-// difference between two regions of memory.

-

-#ifndef COURGETTE_DIFFERENCE_ESTIMATOR_H_

-#define COURGETTE_DIFFERENCE_ESTIMATOR_H_

-

-#include <vector>

-

-#include "third_party/courgette/region.h"

-

-namespace courgette {

-

-// A DifferenceEstimator simplifies the task of determining which 'Subject' byte

-// strings (stored in regions of memory) are good matches to existing 'Base'

-// regions.  The ultimate measure would be to try full differential compression

-// and measure the output size, but an estimate that correlates well with the

-// full compression is more efficient.

-//

-// The measure is asymmetric, if the Subject is a small substring of the Base

-// then it should match very well.

-//

-// The comparison is staged: first make Base and Subject objects for the regions

-// and then call 'Measure' to get the estimate.  The staging allows multiple

-// comparisons to be more efficient by precomputing information used in the

-// comparison.

-//

-class DifferenceEstimator {

- public:

-  DifferenceEstimator();

-  ~DifferenceEstimator();

-

-  class Base;

-  class Subject;

-

-  // This DifferenceEstimator owns the objects returned by MakeBase and

-  // MakeSubject.  Caller continues to own memory at |region| and must not free

-  // it until ~DifferenceEstimator has been called.

-  Base* MakeBase(const Region& region);

-  Subject* MakeSubject(const Region& region);

-

-  // Returns a value correlated with the size of the bsdiff or xdelta difference

-  // from |base| to |subject|.  Returns zero iff the base and subject regions

-  // are bytewise identical.

-  size_t Measure(Base* base,  Subject* subject);

-

- private:

-  std::vector<Base*> owned_bases_;

-  std::vector<Subject*> owned_subjects_;

-  DISALLOW_COPY_AND_ASSIGN(DifferenceEstimator);

-};

-

-}  // namespace

-

-#endif  // COURGETTE_DIFFERENCE_ESTIMATOR_H_

+// Copyright (c) 2009 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.
+
+// A DifferenceEstimator class provides a means for quickly estimating the
+// difference between two regions of memory.
+
+#ifndef COURGETTE_DIFFERENCE_ESTIMATOR_H_
+#define COURGETTE_DIFFERENCE_ESTIMATOR_H_
+
+#include <vector>
+
+#include "courgette/region.h"
+
+namespace courgette {
+
+// A DifferenceEstimator simplifies the task of determining which 'Subject' byte
+// strings (stored in regions of memory) are good matches to existing 'Base'
+// regions.  The ultimate measure would be to try full differential compression
+// and measure the output size, but an estimate that correlates well with the
+// full compression is more efficient.
+//
+// The measure is asymmetric, if the Subject is a small substring of the Base
+// then it should match very well.
+//
+// The comparison is staged: first make Base and Subject objects for the regions
+// and then call 'Measure' to get the estimate.  The staging allows multiple
+// comparisons to be more efficient by precomputing information used in the
+// comparison.
+//
+class DifferenceEstimator {
+ public:
+  DifferenceEstimator();
+  ~DifferenceEstimator();
+
+  class Base;
+  class Subject;
+
+  // This DifferenceEstimator owns the objects returned by MakeBase and
+  // MakeSubject.  Caller continues to own memory at |region| and must not free
+  // it until ~DifferenceEstimator has been called.
+  Base* MakeBase(const Region& region);
+  Subject* MakeSubject(const Region& region);
+
+  // Returns a value correlated with the size of the bsdiff or xdelta difference
+  // from |base| to |subject|.  Returns zero iff the base and subject regions
+  // are bytewise identical.
+  size_t Measure(Base* base,  Subject* subject);
+
+ private:
+  std::vector<Base*> owned_bases_;
+  std::vector<Subject*> owned_subjects_;
+  DISALLOW_COPY_AND_ASSIGN(DifferenceEstimator);
+};
+
+}  // namespace
+
+#endif  // COURGETTE_DIFFERENCE_ESTIMATOR_H_
diff --git a/third_party/courgette/difference_estimator_unittest.cc b/courgette/difference_estimator_unittest.cc
index 6cc8afd..913752b 100644
--- a/third_party/courgette/difference_estimator_unittest.cc
+++ b/courgette/difference_estimator_unittest.cc
@@ -1,58 +1,58 @@
-// Copyright (c) 2009 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.

-

-#include "third_party/courgette/difference_estimator.h"

-

-#include <string>

-

-#include "testing/gtest/include/gtest/gtest.h"

-#include "third_party/courgette/region.h"

-

-using courgette::DifferenceEstimator;

-using courgette::Region;

-

-TEST(DifferenceEstimatorTest, TestSame) {

-  static const char kString1[] = "Hello world";

-  // kString2 is stack allocated to prevent string sharing.

-  const char kString2[] = "Hello world";

-  DifferenceEstimator difference_estimator;

-  DifferenceEstimator::Base* base =

-      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)));

-  DifferenceEstimator::Subject* subject =

-      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)));

-  EXPECT_EQ(0, difference_estimator.Measure(base, subject));

-}

-

-TEST(DifferenceEstimatorTest, TestDifferent) {

-  static const char kString1[] = "Hello world";

-  static const char kString2[] = "Hello universe";

-  DifferenceEstimator difference_estimator;

-  DifferenceEstimator::Base* base =

-      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)));

-  DifferenceEstimator::Subject* subject =

-      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)));

-  EXPECT_EQ(10, difference_estimator.Measure(base, subject));

-}

-

-TEST(DifferenceEstimatorTest, TestDifferentSuperstring) {

-  static const char kString1[] = "abcdabcdabcd";

-  static const char kString2[] = "abcdabcdabcdabcd";

-  DifferenceEstimator difference_estimator;

-  DifferenceEstimator::Base* base =

-      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)-1));

-  DifferenceEstimator::Subject* subject =

-      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)-1));

-  EXPECT_EQ(1, difference_estimator.Measure(base, subject));

-}

-

-TEST(DifferenceEstimatorTest, TestDifferentSubstring) {

-  static const char kString1[] = "abcdabcdabcdabcd";

-  static const char kString2[] = "abcdabcdabcd";

-  DifferenceEstimator difference_estimator;

-  DifferenceEstimator::Base* base =

-      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)-1));

-  DifferenceEstimator::Subject* subject =

-      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)-1));

-  EXPECT_EQ(1, difference_estimator.Measure(base, subject));

-}

+// Copyright (c) 2009 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.
+
+#include "courgette/difference_estimator.h"
+
+#include <string>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "courgette/region.h"
+
+using courgette::DifferenceEstimator;
+using courgette::Region;
+
+TEST(DifferenceEstimatorTest, TestSame) {
+  static const char kString1[] = "Hello world";
+  // kString2 is stack allocated to prevent string sharing.
+  const char kString2[] = "Hello world";
+  DifferenceEstimator difference_estimator;
+  DifferenceEstimator::Base* base =
+      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)));
+  DifferenceEstimator::Subject* subject =
+      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)));
+  EXPECT_EQ(0, difference_estimator.Measure(base, subject));
+}
+
+TEST(DifferenceEstimatorTest, TestDifferent) {
+  static const char kString1[] = "Hello world";
+  static const char kString2[] = "Hello universe";
+  DifferenceEstimator difference_estimator;
+  DifferenceEstimator::Base* base =
+      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)));
+  DifferenceEstimator::Subject* subject =
+      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)));
+  EXPECT_EQ(10, difference_estimator.Measure(base, subject));
+}
+
+TEST(DifferenceEstimatorTest, TestDifferentSuperstring) {
+  static const char kString1[] = "abcdabcdabcd";
+  static const char kString2[] = "abcdabcdabcdabcd";
+  DifferenceEstimator difference_estimator;
+  DifferenceEstimator::Base* base =
+      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)-1));
+  DifferenceEstimator::Subject* subject =
+      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)-1));
+  EXPECT_EQ(1, difference_estimator.Measure(base, subject));
+}
+
+TEST(DifferenceEstimatorTest, TestDifferentSubstring) {
+  static const char kString1[] = "abcdabcdabcdabcd";
+  static const char kString2[] = "abcdabcdabcd";
+  DifferenceEstimator difference_estimator;
+  DifferenceEstimator::Base* base =
+      difference_estimator.MakeBase(Region(kString1, sizeof(kString1)-1));
+  DifferenceEstimator::Subject* subject =
+      difference_estimator.MakeSubject(Region(kString2, sizeof(kString2)-1));
+  EXPECT_EQ(1, difference_estimator.Measure(base, subject));
+}
diff --git a/third_party/courgette/disassembler.cc b/courgette/disassembler.cc
index 6ebb2da..6395d18 100644
--- a/third_party/courgette/disassembler.cc
+++ b/courgette/disassembler.cc
@@ -1,436 +1,436 @@
-// Copyright (c) 2009 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.

-

-#include "third_party/courgette/disassembler.h"

-

-#include <algorithm>

-#include <iostream>

-#include <string>

-#include <vector>

-

-#include "base/basictypes.h"

-#include "base/logging.h"

-

-#include "third_party/courgette/assembly_program.h"

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/encoded_program.h"

-#include "third_party/courgette/image_info.h"

-

-// COURGETTE_HISTOGRAM_TARGETS prints out a histogram of how frequently

-// different target addresses are referenced.  Purely for debugging.

-#define COURGETTE_HISTOGRAM_TARGETS 0

-

-namespace courgette {

-

-class DisassemblerWin32X86 : public Disassembler {

- public:

-  explicit DisassemblerWin32X86(PEInfo* pe_info)

-      : pe_info_(pe_info),

-        incomplete_disassembly_(false) {

-  }

-

-  virtual bool Disassemble(AssemblyProgram* target);

-

-  virtual void Destroy() { delete this; }

-

- protected:

-  PEInfo& pe_info() { return *pe_info_; }

-

-  void ParseFile(AssemblyProgram* target);

-  bool ParseAbs32Relocs();

-  void ParseRel32RelocsFromSections();

-  void ParseRel32RelocsFromSection(const Section* section);

-

-  void ParseNonSectionFileRegion(uint32 start_file_offset,

-                                 uint32 end_file_offset,

-                                 AssemblyProgram* program);

-  void ParseFileRegion(const Section* section,

-                       uint32 start_file_offset, uint32 end_file_offset,

-                       AssemblyProgram* program);

-

-#if COURGETTE_HISTOGRAM_TARGETS

-  void HistogramTargets(const char* kind, const std::map<RVA, int>& map);

-#endif

-

-  PEInfo* pe_info_;

-  bool incomplete_disassembly_;  // 'true' if can leave out 'uninteresting' bits

-

-  std::vector<RVA> abs32_locations_;

-  std::vector<RVA> rel32_locations_;

-

-#if COURGETTE_HISTOGRAM_TARGETS

-  std::map<RVA, int> abs32_target_rvas_;

-  std::map<RVA, int> rel32_target_rvas_;

-#endif

-};

-

-bool DisassemblerWin32X86::Disassemble(AssemblyProgram* target) {

-  if (!pe_info().ok())

-    return false;

-

-  target->set_image_base(pe_info().image_base());

-

-  if (!ParseAbs32Relocs())

-    return false;

-

-  ParseRel32RelocsFromSections();

-

-  ParseFile(target);

-

-  target->DefaultAssignIndexes();

-  return true;

-}

-

-static uint32 Read32LittleEndian(const void* address) {

-  return *reinterpret_cast<const uint32*>(address);

-}

-

-bool DisassemblerWin32X86::ParseAbs32Relocs() {

-  abs32_locations_.clear();

-  if (!pe_info().ParseRelocs(&abs32_locations_))

-    return false;

-

-  std::sort(abs32_locations_.begin(), abs32_locations_.end());

-

-#if COURGETTE_HISTOGRAM_TARGETS

-  for (size_t i = 0;  i < abs32_locations_.size(); ++i) {

-    RVA rva = abs32_locations_[i];

-    // The 4 bytes at the relocation are a reference to some address.

-    uint32 target_address = Read32LittleEndian(pe_info().RVAToPointer(rva));

-    ++abs32_target_rvas_[target_address - pe_info().image_base()];

-  }

-#endif

-  return true;

-}

-

-void DisassemblerWin32X86::ParseRel32RelocsFromSections() {

-  uint32 file_offset = 0;

-  while (file_offset < pe_info().length()) {

-    const Section* section = pe_info().FindNextSection(file_offset);

-    if (section == NULL)

-      break;

-    if (file_offset < section->file_offset_of_raw_data)

-      file_offset = section->file_offset_of_raw_data;

-    ParseRel32RelocsFromSection(section);

-    file_offset += section->size_of_raw_data;

-  }

-  std::sort(rel32_locations_.begin(), rel32_locations_.end());

-

-#if COURGETTE_HISTOGRAM_TARGETS

-  LOG(INFO) << "abs32_locations_ " << abs32_locations_.size();

-  LOG(INFO) << "rel32_locations_ " << rel32_locations_.size();

-  LOG(INFO) << "abs32_target_rvas_ " << abs32_target_rvas_.size();

-  LOG(INFO) << "rel32_target_rvas_ " << rel32_target_rvas_.size();

-

-  int common = 0;

-  std::map<RVA, int>::iterator abs32_iter = abs32_target_rvas_.begin();

-  std::map<RVA, int>::iterator rel32_iter = rel32_target_rvas_.begin();

-  while (abs32_iter != abs32_target_rvas_.end() &&

-         rel32_iter != rel32_target_rvas_.end()) {

-    if (abs32_iter->first < rel32_iter->first)

-      ++abs32_iter;

-    else if (rel32_iter->first < abs32_iter->first)

-      ++rel32_iter;

-    else {

-      ++common;

-      ++abs32_iter;

-      ++rel32_iter;

-    }

-  }

-  LOG(INFO) << "common " << common;

-#endif

-}

-

-void DisassemblerWin32X86::ParseRel32RelocsFromSection(const Section* section) {

-  // TODO(sra): use characteristic.

-  bool isCode = strcmp(section->name, ".text") == 0;

-  if (!isCode)

-    return;

-

-  uint32 start_file_offset = section->file_offset_of_raw_data;

-  uint32 end_file_offset = start_file_offset + section->size_of_raw_data;

-  RVA relocs_start_rva = pe_info().base_relocation_table().address_;

-

-  const uint8* start_pointer = pe_info().FileOffsetToPointer(start_file_offset);

-  const uint8* end_pointer = pe_info().FileOffsetToPointer(end_file_offset);

-

-  RVA start_rva = pe_info().FileOffsetToRVA(start_file_offset);

-  RVA end_rva = start_rva + section->virtual_size;

-

-  // Quick way to convert from Pointer to RVA within a single Section is to

-  // subtract 'pointer_to_rva'.

-  const uint8* const adjust_pointer_to_rva = start_pointer - start_rva;

-

-  std::vector<RVA>::iterator abs32_pos = abs32_locations_.begin();

-

-  // Find the rel32 relocations.

-  const uint8* p = start_pointer;

-  while (p < end_pointer) {

-    RVA current_rva = p - adjust_pointer_to_rva;

-    if (current_rva == relocs_start_rva) {

-      uint32 relocs_size = pe_info().base_relocation_table().size_;

-      if (relocs_size) {

-        p += relocs_size;

-        continue;

-      }

-    }

-

-    //while (abs32_pos != abs32_locations_.end() && *abs32_pos < current_rva)

-    //  ++abs32_pos;

-

-    // Heuristic discovery of rel32 locations in instruction stream: are the

-    // next few bytes the start of an instruction containing a rel32

-    // addressing mode?

-    const uint8* rel32 = NULL;

-

-    if (p + 5 < end_pointer) {

-      if (*p == 0xE8 || *p == 0xE9) {  // jmp rel32 and call rel32

-        rel32 = p + 1;

-      }

-    }

-    if (p + 6 < end_pointer) {

-      if (*p == 0x0F  &&  (*(p+1) & 0xF0) == 0x80) {  // Jcc long form

-        if (p[1] != 0x8A && p[1] != 0x8B)  // JPE/JPO unlikely

-          rel32 = p + 2;

-      }

-    }

-    if (rel32) {

-      RVA rel32_rva = rel32 - adjust_pointer_to_rva;

-

-      // Is there an abs32 reloc overlapping the candidate?

-      while (abs32_pos != abs32_locations_.end() && *abs32_pos < rel32_rva - 3)

-        ++abs32_pos;

-      // Now: (*abs32_pos > rel32_rva - 4) i.e. the lowest addressed 4-byte

-      // region that could overlap rel32_rva.

-      if (abs32_pos != abs32_locations_.end()) {

-        if (*abs32_pos < rel32_rva + 4) {

-          // Beginning of abs32 reloc is before end of rel32 reloc so they

-          // overlap.  Skip four bytes past the abs32 reloc.

-          p += (*abs32_pos + 4) - current_rva;

-          continue;

-        }

-      }

-

-      RVA target_rva = rel32_rva + 4 + Read32LittleEndian(rel32);

-      // To be valid, rel32 target must be within image, and within this

-      // section.

-      if (pe_info().IsValidRVA(target_rva) &&

-          start_rva <= target_rva && target_rva < end_rva) {

-        rel32_locations_.push_back(rel32_rva);

-#if COURGETTE_HISTOGRAM_TARGETS

-        ++rel32_target_rvas_[target_rva];

-#endif

-        p += 4;

-        continue;

-      }

-    }

-    p += 1;

-  }

-}

-

-void DisassemblerWin32X86::ParseFile(AssemblyProgram* program) {

-  // Walk all the bytes in the file, whether or not in a section.

-  uint32 file_offset = 0;

-  while (file_offset < pe_info().length()) {

-    const Section* section = pe_info().FindNextSection(file_offset);

-    if (section == NULL) {

-      // No more sections.  There should not be extra stuff following last

-      // section.

-      //   ParseNonSectionFileRegion(file_offset, pe_info().length(), program);

-      break;

-    }

-    if (file_offset < section->file_offset_of_raw_data) {

-      uint32 section_start_offset = section->file_offset_of_raw_data;

-      ParseNonSectionFileRegion(file_offset, section_start_offset, program);

-      file_offset = section_start_offset;

-    }

-    uint32 end = file_offset + section->size_of_raw_data;

-    ParseFileRegion(section, file_offset, end, program);

-    file_offset = end;

-  }

-

-#if COURGETTE_HISTOGRAM_TARGETS

-  HistogramTargets("abs32 relocs", abs32_target_rvas_);

-  HistogramTargets("rel32 relocs", rel32_target_rvas_);

-#endif

-}

-

-void DisassemblerWin32X86::ParseNonSectionFileRegion(

-    uint32 start_file_offset,

-    uint32 end_file_offset,

-    AssemblyProgram* program) {

-  if (incomplete_disassembly_)

-    return;

-

-  const uint8* start = pe_info().FileOffsetToPointer(start_file_offset);

-  const uint8* end = pe_info().FileOffsetToPointer(end_file_offset);

-

-  const uint8* p = start;

-

-  while (p < end) {

-    program->EmitByteInstruction(*p);

-    ++p;

-  }

-}

-

-void DisassemblerWin32X86::ParseFileRegion(

-    const Section* section,

-    uint32 start_file_offset, uint32 end_file_offset,

-    AssemblyProgram* program) {

-  RVA relocs_start_rva = pe_info().base_relocation_table().address_;

-

-  const uint8* start_pointer = pe_info().FileOffsetToPointer(start_file_offset);

-  const uint8* end_pointer = pe_info().FileOffsetToPointer(end_file_offset);

-

-  RVA start_rva = pe_info().FileOffsetToRVA(start_file_offset);

-  RVA end_rva = start_rva + section->virtual_size;

-

-  // Quick way to convert from Pointer to RVA within a single Section is to

-  // subtract 'pointer_to_rva'.

-  const uint8* const adjust_pointer_to_rva = start_pointer - start_rva;

-

-  std::vector<RVA>::iterator rel32_pos = rel32_locations_.begin();

-  std::vector<RVA>::iterator abs32_pos = abs32_locations_.begin();

-

-  program->EmitOriginInstruction(start_rva);

-

-  const uint8* p = start_pointer;

-

-  while (p < end_pointer) {

-    RVA current_rva = p - adjust_pointer_to_rva;

-

-    // The base relocation table is usually in the .relocs section, but it could

-    // actually be anywhere.  Make sure we skip it because we will regenerate it

-    // during assembly.

-    if (current_rva == relocs_start_rva) {

-      program->EmitMakeRelocsInstruction();

-      uint32 relocs_size = pe_info().base_relocation_table().size_;

-      if (relocs_size) {

-        p += relocs_size;

-        continue;

-      }

-    }

-

-    while (abs32_pos != abs32_locations_.end() && *abs32_pos < current_rva)

-      ++abs32_pos;

-

-    if (abs32_pos != abs32_locations_.end() && *abs32_pos == current_rva) {

-      uint32 target_address = Read32LittleEndian(p);

-      RVA target_rva = target_address - pe_info().image_base();

-      // TODO(sra): target could be Label+offset.  It is not clear how to guess

-      // which it might be.  We assume offset==0.

-      program->EmitAbs32(program->FindOrMakeAbs32Label(target_rva));

-      p += 4;

-      continue;

-    }

-

-    while (rel32_pos != rel32_locations_.end() && *rel32_pos < current_rva)

-      ++rel32_pos;

-

-    if (rel32_pos != rel32_locations_.end() && *rel32_pos == current_rva) {

-      RVA target_rva = current_rva + 4 + Read32LittleEndian(p);

-      program->EmitRel32(program->FindOrMakeRel32Label(target_rva));

-      p += 4;

-      continue;

-    }

-

-    if (incomplete_disassembly_) {

-      if ((abs32_pos == abs32_locations_.end() || end_rva <= *abs32_pos) &&

-          (rel32_pos == rel32_locations_.end() || end_rva <= *rel32_pos) &&

-          (end_rva <= relocs_start_rva || current_rva >= relocs_start_rva)) {

-        // No more relocs in this section, don't bother encoding bytes.

-        break;

-      }

-    }

-

-    program->EmitByteInstruction(*p);

-    p += 1;

-  }

-}

-

-#if COURGETTE_HISTOGRAM_TARGETS

-// Histogram is printed to std::cout.  It is purely for debugging the algorithm

-// and is only enabled manually in 'exploration' builds.  I don't want to add

-// command-line configuration for this feature because this code has to be

-// small, which means compiled-out.

-void DisassemblerWin32X86::HistogramTargets(const char* kind,

-                                            const std::map<RVA, int>& map) {

-  int total = 0;

-  std::map<int, std::vector<RVA> > h;

-  for (std::map<RVA, int>::const_iterator p = map.begin();

-       p != map.end();

-       ++p) {

-    h[p->second].push_back(p->first);

-    total += p->second;

-  }

-

-  std::cout << total << " " << kind << " to "

-            << map.size() << " unique targets" << std::endl;

-

-  std::cout << "indegree: #targets-with-indegree (example)" << std::endl;

-  const int kFirstN = 15;

-  bool someSkipped = false;

-  int index = 0;

-  for (std::map<int, std::vector<RVA> >::reverse_iterator p = h.rbegin();

-       p != h.rend();

-       ++p) {

-    ++index;

-    if (index <= kFirstN || p->first <= 3) {

-      if (someSkipped) {

-        std::cout << "..." << std::endl;

-      }

-      size_t count = p->second.size();

-      std::cout << std::dec << p->first << ": " << count;

-      if (count <= 2) {

-        for (size_t i = 0;  i < count;  ++i)

-          std::cout << "  " << pe_info().DescribeRVA(p->second[i]);

-      }

-      std::cout << std::endl;

-      someSkipped = false;

-    } else {

-      someSkipped = true;

-    }

-  }

-}

-#endif  // COURGETTE_HISTOGRAM_TARGETS

-

-Disassembler* Disassembler::MakeDisassemberWin32X86(PEInfo* pe_info) {

-  return new DisassemblerWin32X86(pe_info);

-}

-

-////////////////////////////////////////////////////////////////////////////////

-

-Status ParseWin32X86PE(const void* buffer, size_t length,

-                       AssemblyProgram** output) {

-  *output = NULL;

-

-  PEInfo* pe_info = new PEInfo();

-  pe_info->Init(buffer, length);

-

-  if (!pe_info->ParseHeader()) {

-    delete pe_info;

-    return C_INPUT_NOT_RECOGNIZED;

-  }

-

-  Disassembler* disassembler = Disassembler::MakeDisassemberWin32X86(pe_info);

-  AssemblyProgram* program = new AssemblyProgram();

-

-  if (!disassembler->Disassemble(program)) {

-    delete program;

-    disassembler->Destroy();

-    delete pe_info;

-    return C_DISASSEMBLY_FAILED;

-  }

-

-  disassembler->Destroy();

-  delete pe_info;

-  *output = program;

-  return C_OK;

-}

-

-void DeleteAssemblyProgram(AssemblyProgram* program) {

-  delete program;

-}

-

-}  // namespace courgette

+// Copyright (c) 2009 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.
+
+#include "courgette/disassembler.h"
+
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+
+#include "courgette/assembly_program.h"
+#include "courgette/courgette.h"
+#include "courgette/encoded_program.h"
+#include "courgette/image_info.h"
+
+// COURGETTE_HISTOGRAM_TARGETS prints out a histogram of how frequently
+// different target addresses are referenced.  Purely for debugging.
+#define COURGETTE_HISTOGRAM_TARGETS 0
+
+namespace courgette {
+
+class DisassemblerWin32X86 : public Disassembler {
+ public:
+  explicit DisassemblerWin32X86(PEInfo* pe_info)
+      : pe_info_(pe_info),
+        incomplete_disassembly_(false) {
+  }
+
+  virtual bool Disassemble(AssemblyProgram* target);
+
+  virtual void Destroy() { delete this; }
+
+ protected:
+  PEInfo& pe_info() { return *pe_info_; }
+
+  void ParseFile(AssemblyProgram* target);
+  bool ParseAbs32Relocs();
+  void ParseRel32RelocsFromSections();
+  void ParseRel32RelocsFromSection(const Section* section);
+
+  void ParseNonSectionFileRegion(uint32 start_file_offset,
+                                 uint32 end_file_offset,
+                                 AssemblyProgram* program);
+  void ParseFileRegion(const Section* section,
+                       uint32 start_file_offset, uint32 end_file_offset,
+                       AssemblyProgram* program);
+
+#if COURGETTE_HISTOGRAM_TARGETS
+  void HistogramTargets(const char* kind, const std::map<RVA, int>& map);
+#endif
+
+  PEInfo* pe_info_;
+  bool incomplete_disassembly_;  // 'true' if can leave out 'uninteresting' bits
+
+  std::vector<RVA> abs32_locations_;
+  std::vector<RVA> rel32_locations_;
+
+#if COURGETTE_HISTOGRAM_TARGETS
+  std::map<RVA, int> abs32_target_rvas_;
+  std::map<RVA, int> rel32_target_rvas_;
+#endif
+};
+
+bool DisassemblerWin32X86::Disassemble(AssemblyProgram* target) {
+  if (!pe_info().ok())
+    return false;
+
+  target->set_image_base(pe_info().image_base());
+
+  if (!ParseAbs32Relocs())
+    return false;
+
+  ParseRel32RelocsFromSections();
+
+  ParseFile(target);
+
+  target->DefaultAssignIndexes();
+  return true;
+}
+
+static uint32 Read32LittleEndian(const void* address) {
+  return *reinterpret_cast<const uint32*>(address);
+}
+
+bool DisassemblerWin32X86::ParseAbs32Relocs() {
+  abs32_locations_.clear();
+  if (!pe_info().ParseRelocs(&abs32_locations_))
+    return false;
+
+  std::sort(abs32_locations_.begin(), abs32_locations_.end());
+
+#if COURGETTE_HISTOGRAM_TARGETS
+  for (size_t i = 0;  i < abs32_locations_.size(); ++i) {
+    RVA rva = abs32_locations_[i];
+    // The 4 bytes at the relocation are a reference to some address.
+    uint32 target_address = Read32LittleEndian(pe_info().RVAToPointer(rva));
+    ++abs32_target_rvas_[target_address - pe_info().image_base()];
+  }
+#endif
+  return true;
+}
+
+void DisassemblerWin32X86::ParseRel32RelocsFromSections() {
+  uint32 file_offset = 0;
+  while (file_offset < pe_info().length()) {
+    const Section* section = pe_info().FindNextSection(file_offset);
+    if (section == NULL)
+      break;
+    if (file_offset < section->file_offset_of_raw_data)
+      file_offset = section->file_offset_of_raw_data;
+    ParseRel32RelocsFromSection(section);
+    file_offset += section->size_of_raw_data;
+  }
+  std::sort(rel32_locations_.begin(), rel32_locations_.end());
+
+#if COURGETTE_HISTOGRAM_TARGETS
+  LOG(INFO) << "abs32_locations_ " << abs32_locations_.size();
+  LOG(INFO) << "rel32_locations_ " << rel32_locations_.size();
+  LOG(INFO) << "abs32_target_rvas_ " << abs32_target_rvas_.size();
+  LOG(INFO) << "rel32_target_rvas_ " << rel32_target_rvas_.size();
+
+  int common = 0;
+  std::map<RVA, int>::iterator abs32_iter = abs32_target_rvas_.begin();
+  std::map<RVA, int>::iterator rel32_iter = rel32_target_rvas_.begin();
+  while (abs32_iter != abs32_target_rvas_.end() &&
+         rel32_iter != rel32_target_rvas_.end()) {
+    if (abs32_iter->first < rel32_iter->first)
+      ++abs32_iter;
+    else if (rel32_iter->first < abs32_iter->first)
+      ++rel32_iter;
+    else {
+      ++common;
+      ++abs32_iter;
+      ++rel32_iter;
+    }
+  }
+  LOG(INFO) << "common " << common;
+#endif
+}
+
+void DisassemblerWin32X86::ParseRel32RelocsFromSection(const Section* section) {
+  // TODO(sra): use characteristic.
+  bool isCode = strcmp(section->name, ".text") == 0;
+  if (!isCode)
+    return;
+
+  uint32 start_file_offset = section->file_offset_of_raw_data;
+  uint32 end_file_offset = start_file_offset + section->size_of_raw_data;
+  RVA relocs_start_rva = pe_info().base_relocation_table().address_;
+
+  const uint8* start_pointer = pe_info().FileOffsetToPointer(start_file_offset);
+  const uint8* end_pointer = pe_info().FileOffsetToPointer(end_file_offset);
+
+  RVA start_rva = pe_info().FileOffsetToRVA(start_file_offset);
+  RVA end_rva = start_rva + section->virtual_size;
+
+  // Quick way to convert from Pointer to RVA within a single Section is to
+  // subtract 'pointer_to_rva'.
+  const uint8* const adjust_pointer_to_rva = start_pointer - start_rva;
+
+  std::vector<RVA>::iterator abs32_pos = abs32_locations_.begin();
+
+  // Find the rel32 relocations.
+  const uint8* p = start_pointer;
+  while (p < end_pointer) {
+    RVA current_rva = p - adjust_pointer_to_rva;
+    if (current_rva == relocs_start_rva) {
+      uint32 relocs_size = pe_info().base_relocation_table().size_;
+      if (relocs_size) {
+        p += relocs_size;
+        continue;
+      }
+    }
+
+    //while (abs32_pos != abs32_locations_.end() && *abs32_pos < current_rva)
+    //  ++abs32_pos;
+
+    // Heuristic discovery of rel32 locations in instruction stream: are the
+    // next few bytes the start of an instruction containing a rel32
+    // addressing mode?
+    const uint8* rel32 = NULL;
+
+    if (p + 5 < end_pointer) {
+      if (*p == 0xE8 || *p == 0xE9) {  // jmp rel32 and call rel32
+        rel32 = p + 1;
+      }
+    }
+    if (p + 6 < end_pointer) {
+      if (*p == 0x0F  &&  (*(p+1) & 0xF0) == 0x80) {  // Jcc long form
+        if (p[1] != 0x8A && p[1] != 0x8B)  // JPE/JPO unlikely
+          rel32 = p + 2;
+      }
+    }
+    if (rel32) {
+      RVA rel32_rva = rel32 - adjust_pointer_to_rva;
+
+      // Is there an abs32 reloc overlapping the candidate?
+      while (abs32_pos != abs32_locations_.end() && *abs32_pos < rel32_rva - 3)
+        ++abs32_pos;
+      // Now: (*abs32_pos > rel32_rva - 4) i.e. the lowest addressed 4-byte
+      // region that could overlap rel32_rva.
+      if (abs32_pos != abs32_locations_.end()) {
+        if (*abs32_pos < rel32_rva + 4) {
+          // Beginning of abs32 reloc is before end of rel32 reloc so they
+          // overlap.  Skip four bytes past the abs32 reloc.
+          p += (*abs32_pos + 4) - current_rva;
+          continue;
+        }
+      }
+
+      RVA target_rva = rel32_rva + 4 + Read32LittleEndian(rel32);
+      // To be valid, rel32 target must be within image, and within this
+      // section.
+      if (pe_info().IsValidRVA(target_rva) &&
+          start_rva <= target_rva && target_rva < end_rva) {
+        rel32_locations_.push_back(rel32_rva);
+#if COURGETTE_HISTOGRAM_TARGETS
+        ++rel32_target_rvas_[target_rva];
+#endif
+        p += 4;
+        continue;
+      }
+    }
+    p += 1;
+  }
+}
+
+void DisassemblerWin32X86::ParseFile(AssemblyProgram* program) {
+  // Walk all the bytes in the file, whether or not in a section.
+  uint32 file_offset = 0;
+  while (file_offset < pe_info().length()) {
+    const Section* section = pe_info().FindNextSection(file_offset);
+    if (section == NULL) {
+      // No more sections.  There should not be extra stuff following last
+      // section.
+      //   ParseNonSectionFileRegion(file_offset, pe_info().length(), program);
+      break;
+    }
+    if (file_offset < section->file_offset_of_raw_data) {
+      uint32 section_start_offset = section->file_offset_of_raw_data;
+      ParseNonSectionFileRegion(file_offset, section_start_offset, program);
+      file_offset = section_start_offset;
+    }
+    uint32 end = file_offset + section->size_of_raw_data;
+    ParseFileRegion(section, file_offset, end, program);
+    file_offset = end;
+  }
+
+#if COURGETTE_HISTOGRAM_TARGETS
+  HistogramTargets("abs32 relocs", abs32_target_rvas_);
+  HistogramTargets("rel32 relocs", rel32_target_rvas_);
+#endif
+}
+
+void DisassemblerWin32X86::ParseNonSectionFileRegion(
+    uint32 start_file_offset,
+    uint32 end_file_offset,
+    AssemblyProgram* program) {
+  if (incomplete_disassembly_)
+    return;
+
+  const uint8* start = pe_info().FileOffsetToPointer(start_file_offset);
+  const uint8* end = pe_info().FileOffsetToPointer(end_file_offset);
+
+  const uint8* p = start;
+
+  while (p < end) {
+    program->EmitByteInstruction(*p);
+    ++p;
+  }
+}
+
+void DisassemblerWin32X86::ParseFileRegion(
+    const Section* section,
+    uint32 start_file_offset, uint32 end_file_offset,
+    AssemblyProgram* program) {
+  RVA relocs_start_rva = pe_info().base_relocation_table().address_;
+
+  const uint8* start_pointer = pe_info().FileOffsetToPointer(start_file_offset);
+  const uint8* end_pointer = pe_info().FileOffsetToPointer(end_file_offset);
+
+  RVA start_rva = pe_info().FileOffsetToRVA(start_file_offset);
+  RVA end_rva = start_rva + section->virtual_size;
+
+  // Quick way to convert from Pointer to RVA within a single Section is to
+  // subtract 'pointer_to_rva'.
+  const uint8* const adjust_pointer_to_rva = start_pointer - start_rva;
+
+  std::vector<RVA>::iterator rel32_pos = rel32_locations_.begin();
+  std::vector<RVA>::iterator abs32_pos = abs32_locations_.begin();
+
+  program->EmitOriginInstruction(start_rva);
+
+  const uint8* p = start_pointer;
+
+  while (p < end_pointer) {
+    RVA current_rva = p - adjust_pointer_to_rva;
+
+    // The base relocation table is usually in the .relocs section, but it could
+    // actually be anywhere.  Make sure we skip it because we will regenerate it
+    // during assembly.
+    if (current_rva == relocs_start_rva) {
+      program->EmitMakeRelocsInstruction();
+      uint32 relocs_size = pe_info().base_relocation_table().size_;
+      if (relocs_size) {
+        p += relocs_size;
+        continue;
+      }
+    }
+
+    while (abs32_pos != abs32_locations_.end() && *abs32_pos < current_rva)
+      ++abs32_pos;
+
+    if (abs32_pos != abs32_locations_.end() && *abs32_pos == current_rva) {
+      uint32 target_address = Read32LittleEndian(p);
+      RVA target_rva = target_address - pe_info().image_base();
+      // TODO(sra): target could be Label+offset.  It is not clear how to guess
+      // which it might be.  We assume offset==0.
+      program->EmitAbs32(program->FindOrMakeAbs32Label(target_rva));
+      p += 4;
+      continue;
+    }
+
+    while (rel32_pos != rel32_locations_.end() && *rel32_pos < current_rva)
+      ++rel32_pos;
+
+    if (rel32_pos != rel32_locations_.end() && *rel32_pos == current_rva) {
+      RVA target_rva = current_rva + 4 + Read32LittleEndian(p);
+      program->EmitRel32(program->FindOrMakeRel32Label(target_rva));
+      p += 4;
+      continue;
+    }
+
+    if (incomplete_disassembly_) {
+      if ((abs32_pos == abs32_locations_.end() || end_rva <= *abs32_pos) &&
+          (rel32_pos == rel32_locations_.end() || end_rva <= *rel32_pos) &&
+          (end_rva <= relocs_start_rva || current_rva >= relocs_start_rva)) {
+        // No more relocs in this section, don't bother encoding bytes.
+        break;
+      }
+    }
+
+    program->EmitByteInstruction(*p);
+    p += 1;
+  }
+}
+
+#if COURGETTE_HISTOGRAM_TARGETS
+// Histogram is printed to std::cout.  It is purely for debugging the algorithm
+// and is only enabled manually in 'exploration' builds.  I don't want to add
+// command-line configuration for this feature because this code has to be
+// small, which means compiled-out.
+void DisassemblerWin32X86::HistogramTargets(const char* kind,
+                                            const std::map<RVA, int>& map) {
+  int total = 0;
+  std::map<int, std::vector<RVA> > h;
+  for (std::map<RVA, int>::const_iterator p = map.begin();
+       p != map.end();
+       ++p) {
+    h[p->second].push_back(p->first);
+    total += p->second;
+  }
+
+  std::cout << total << " " << kind << " to "
+            << map.size() << " unique targets" << std::endl;
+
+  std::cout << "indegree: #targets-with-indegree (example)" << std::endl;
+  const int kFirstN = 15;
+  bool someSkipped = false;
+  int index = 0;
+  for (std::map<int, std::vector<RVA> >::reverse_iterator p = h.rbegin();
+       p != h.rend();
+       ++p) {
+    ++index;
+    if (index <= kFirstN || p->first <= 3) {
+      if (someSkipped) {
+        std::cout << "..." << std::endl;
+      }
+      size_t count = p->second.size();
+      std::cout << std::dec << p->first << ": " << count;
+      if (count <= 2) {
+        for (size_t i = 0;  i < count;  ++i)
+          std::cout << "  " << pe_info().DescribeRVA(p->second[i]);
+      }
+      std::cout << std::endl;
+      someSkipped = false;
+    } else {
+      someSkipped = true;
+    }
+  }
+}
+#endif  // COURGETTE_HISTOGRAM_TARGETS
+
+Disassembler* Disassembler::MakeDisassemberWin32X86(PEInfo* pe_info) {
+  return new DisassemblerWin32X86(pe_info);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+Status ParseWin32X86PE(const void* buffer, size_t length,
+                       AssemblyProgram** output) {
+  *output = NULL;
+
+  PEInfo* pe_info = new PEInfo();
+  pe_info->Init(buffer, length);
+
+  if (!pe_info->ParseHeader()) {
+    delete pe_info;
+    return C_INPUT_NOT_RECOGNIZED;
+  }
+
+  Disassembler* disassembler = Disassembler::MakeDisassemberWin32X86(pe_info);
+  AssemblyProgram* program = new AssemblyProgram();
+
+  if (!disassembler->Disassemble(program)) {
+    delete program;
+    disassembler->Destroy();
+    delete pe_info;
+    return C_DISASSEMBLY_FAILED;
+  }
+
+  disassembler->Destroy();
+  delete pe_info;
+  *output = program;
+  return C_OK;
+}
+
+void DeleteAssemblyProgram(AssemblyProgram* program) {
+  delete program;
+}
+
+}  // namespace courgette
diff --git a/third_party/courgette/disassembler.h b/courgette/disassembler.h
index 595412e..fa7c908 100644
--- a/third_party/courgette/disassembler.h
+++ b/courgette/disassembler.h
@@ -1,39 +1,38 @@
-// Copyright (c) 2009 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.

-

-#ifndef COURGETTE_DISASSEMBLER_H_

-#define COURGETTE_DISASSEMBLER_H_

-

-#include "base/basictypes.h"

-

-namespace courgette {

-

-class AssemblyProgram;

-class PEInfo;

-

-class Disassembler {

- public:

-  // Factory methods for making disassemblers for various kinds of executables.

-  // We have only one so far.

-

-  static Disassembler* MakeDisassemberWin32X86(PEInfo* pe_info);

-

-  // Disassembles the item passed to the factory method into the output

-  // parameter 'program'.

-  virtual bool Disassemble(AssemblyProgram* program) = 0;

-

-  // Deletes 'this' disassembler.

-  virtual void Destroy() = 0;

-

- protected:

-  Disassembler() {}

-  virtual ~Disassembler() {}

-

- private:

-  DISALLOW_COPY_AND_ASSIGN(Disassembler);

-};

-

-}  // namespace courgette

-#endif  // COURGETTE_DISASSEMBLER_H_

-

+// Copyright (c) 2009 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.
+
+#ifndef COURGETTE_DISASSEMBLER_H_
+#define COURGETTE_DISASSEMBLER_H_
+
+#include "base/basictypes.h"
+
+namespace courgette {
+
+class AssemblyProgram;
+class PEInfo;
+
+class Disassembler {
+ public:
+  // Factory methods for making disassemblers for various kinds of executables.
+  // We have only one so far.
+
+  static Disassembler* MakeDisassemberWin32X86(PEInfo* pe_info);
+
+  // Disassembles the item passed to the factory method into the output
+  // parameter 'program'.
+  virtual bool Disassemble(AssemblyProgram* program) = 0;
+
+  // Deletes 'this' disassembler.
+  virtual void Destroy() = 0;
+
+ protected:
+  Disassembler() {}
+  virtual ~Disassembler() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Disassembler);
+};
+
+}  // namespace courgette
+#endif  // COURGETTE_DISASSEMBLER_H_
diff --git a/third_party/courgette/encode_decode_unittest.cc b/courgette/encode_decode_unittest.cc
index 25a3913..436479d8 100644
--- a/third_party/courgette/encode_decode_unittest.cc
+++ b/courgette/encode_decode_unittest.cc
@@ -8,8 +8,8 @@
 #include "base/file_util.h"
 #include "base/string_util.h"
 
-#include "third_party/courgette/courgette.h"
-#include "third_party/courgette/streams.h"
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -20,7 +20,6 @@ class EncodeDecodeTest : public testing::Test {
  private:
   void SetUp() {
     PathService::Get(base::DIR_SOURCE_ROOT, &testdata_dir_);
-    // file_util::AppendToPath(&testdata_dir_, L"third_party");
     file_util::AppendToPath(&testdata_dir_, L"courgette");
     file_util::AppendToPath(&testdata_dir_, L"testdata");
   }
diff --git a/third_party/courgette/encoded_program.cc b/courgette/encoded_program.cc
index 0e9f164..f606f96 100644
--- a/third_party/courgette/encoded_program.cc
+++ b/courgette/encoded_program.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/courgette/encoded_program.h"
+#include "courgette/encoded_program.h"
 
 #include <algorithm>
 #include <map>
@@ -12,8 +12,8 @@
 #include "base/logging.h"
 #include "base/sys_info.h"
 
-#include "third_party/courgette/courgette.h"
-#include "third_party/courgette/streams.h"
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
 
 namespace courgette {
 
diff --git a/third_party/courgette/encoded_program.h b/courgette/encoded_program.h
index 7331042..df1119c 100644
--- a/third_party/courgette/encoded_program.h
+++ b/courgette/encoded_program.h
@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "base/basictypes.h"
-#include "third_party/courgette/image_info.h"
+#include "courgette/image_info.h"
 
 namespace courgette {
 
@@ -81,4 +81,3 @@ class EncodedProgram {
 
 }  // namespace courgette
 #endif  // COURGETTE_ENCODED_FORMAT_H_
-
diff --git a/third_party/courgette/encoded_program_fuzz_unittest.cc b/courgette/encoded_program_fuzz_unittest.cc
index 9cd5020..adc09d9 100644
--- a/third_party/courgette/encoded_program_fuzz_unittest.cc
+++ b/courgette/encoded_program_fuzz_unittest.cc
@@ -1,236 +1,235 @@
-// Copyright (c) 2009 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.

-

-// Fuzz testing for EncodedProgram serialized format and assembly.

-//

-// We would like some assurance that if an EncodedProgram is malformed we will

-// not crash.  The EncodedProgram could be malformed either due to malicious

-// attack to due to an error in patch generation.

-//

-// We try a lot of arbitrary modifications to the serialized form and make sure

-// that the outcome is not a crash.

-

-#include <string>

-

-#include "base/path_service.h"

-#include "base/file_util.h"

-#include "base/string_util.h"

-#include "base/test_suite.h"

-

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/streams.h"

-

-#include "testing/gtest/include/gtest/gtest.h"

-

-class DecodeFuzzTest : public testing::Test {

- public:

-  void FuzzExe(const char *) const;

-

- private:

-  virtual void SetUp() {

-    PathService::Get(base::DIR_SOURCE_ROOT, &testdata_dir_);

-    // testdata_dir_ = testdata_dir_.Append(L"third_party");

-    testdata_dir_ = testdata_dir_.Append(L"courgette");

-    testdata_dir_ = testdata_dir_.Append(L"testdata");

-  }

-

-  virtual void TearDown() { }

-

-  void FuzzByte(const std::string& buffer, const std::string& output,

-                size_t index) const;

-  void FuzzBits(const std::string& buffer, const std::string& output,

-                size_t index, int bits_to_flip) const;

-

-  // Returns true if could assemble, false if rejected.

-  bool TryAssemble(const std::string& buffer, std::string* output) const;

-

-  // Returns contents of |file_name| as uninterprested bytes stored in a string.

-  std::string FileContents(const char* file_name) const;

-

-  // Full path name of testdata directory

-  FilePath testdata_dir_;

-};

-

-//  Reads a test file into a string.

-std::string DecodeFuzzTest::FileContents(const char* file_name) const {

-  FilePath file_path = testdata_dir_.AppendASCII(file_name);

-  std::string file_contents;

-  if (!file_util::ReadFileToString(file_path, &file_contents)) {

-    EXPECT_TRUE(!"Could not read test data");

-  }

-  return file_contents;

-}

-

-// Loads an executable and does fuzz testing in the serialized format.

-void DecodeFuzzTest::FuzzExe(const char* file_name) const {

-  std::string file1 = FileContents(file_name);

-

-  const void* original_buffer = file1.c_str();

-  size_t original_length = file1.size();

-

-  courgette::AssemblyProgram* program = NULL;

-  const courgette::Status parse_status =

-      courgette::ParseWin32X86PE(original_buffer, original_length, &program);

-  EXPECT_EQ(courgette::C_OK, parse_status);

-

-  courgette::EncodedProgram* encoded = NULL;

-

-  const courgette::Status encode_status = Encode(program, &encoded);

-  EXPECT_EQ(courgette::C_OK, encode_status);

-

-  DeleteAssemblyProgram(program);

-

-  courgette::SinkStreamSet sinks;

-  const courgette::Status write_status = WriteEncodedProgram(encoded, &sinks);

-  EXPECT_EQ(courgette::C_OK, write_status);

-

-  DeleteEncodedProgram(encoded);

-

-  courgette::SinkStream sink;

-  bool can_collect = sinks.CopyTo(&sink);

-  EXPECT_TRUE(can_collect);

-

-  size_t length = sink.Length();

-

-  std::string base_buffer(reinterpret_cast<const char*>(sink.Buffer()), length);

-  std::string base_output;

-  bool ok = TryAssemble(base_buffer, &base_output);

-  EXPECT_EQ(true, ok);

-

-  // Now we have a good serialized EncodedProgram in |base_buffer|. Time to

-  // fuzz.

-

-  // More intense fuzzing on the first part because it contains more control

-  // information like substeam lengths.

-  size_t position = 0;

-  for ( ;  position < 100 && position < length;  position += 1) {

-    FuzzByte(base_buffer, base_output, position);

-  }

-  // We would love to fuzz every position, but it takes too long.

-  for ( ;  position < length;  position += 900) {

-    FuzzByte(base_buffer, base_output, position);

-  }

-}

-

-// FuzzByte tries to break the EncodedProgram deserializer and assembler.  It

-// takes a good serialization of and EncodedProgram, flips some bits, and checks

-// that the behaviour is reasonable.  It has testing checks for unreasonable

-// behaviours.

-void DecodeFuzzTest::FuzzByte(const std::string& base_buffer,

-                              const std::string& base_output,

-                              size_t index) const {

-  printf("Fuzzing position %d\n", static_cast<int>(index));

-

-  // The following 10 values are a compromize between run time and coverage of

-  // the 255 'wrong' values at this byte position.

-

-  // 0xFF flips all the bits.

-  FuzzBits(base_buffer, base_output, index, 0xFF);

-  // 0x7F flips the most bits without changing Varint32 framing.

-  FuzzBits(base_buffer, base_output, index, 0x7F);

-  // These all flip one bit.

-  FuzzBits(base_buffer, base_output, index, 0x80);

-  FuzzBits(base_buffer, base_output, index, 0x40);

-  FuzzBits(base_buffer, base_output, index, 0x20);

-  FuzzBits(base_buffer, base_output, index, 0x10);

-  FuzzBits(base_buffer, base_output, index, 0x08);

-  FuzzBits(base_buffer, base_output, index, 0x04);

-  FuzzBits(base_buffer, base_output, index, 0x02);

-  FuzzBits(base_buffer, base_output, index, 0x01);

-}

-

-// FuzzBits tries to break the EncodedProgram deserializer and assembler.  It

-// takes a good serialization of and EncodedProgram, flips some bits, and checks

-// that the behaviour is reasonable.

-//

-// There are EXPECT calls to check for unreasonable behaviour.  These are

-// somewhat arbitrary in that the parameters cannot easily be derived from first

-// principles.  They may need updating as the serialized format evolves.

-void DecodeFuzzTest::FuzzBits(const std::string& base_buffer,

-                              const std::string& base_output,

-                              size_t index, int bits_to_flip) const {

-  std::string modified_buffer = base_buffer;

-  std::string modified_output;

-  modified_buffer[index] ^= bits_to_flip;

-

-  bool ok = TryAssemble(modified_buffer, &modified_output);

-

-  if (ok) {

-    // We normally expect TryAssemble to fail.  But sometimes it succeeds.

-    // What could have happened?  We changed one byte in the serialized form:

-    //

-    //  * If we changed one of the copied bytes, we would see a single byte

-    //    change in the output.

-    //  * If we changed an address table element, all the references to that

-    //    address would be different.

-    //  * If we changed a copy count, we would run out of data in some stream,

-    //    or leave data remaining, so should not be here.

-    //  * If we changed an origin address, it could affect all relocations based

-    //    off that address.  If no relocations were based off the address then

-    //    there will be no changes.

-    //  * If we changed an origin address, it could cause some abs32 relocs to

-    //    shift from one page to the next, changing the number and layout of

-    //    blocks in the base relocation table.

-

-    // Generated length could vary slightly due to base relocation table layout.

-    // In the worst case the number of base relocation blocks doubles, approx

-    // 12/4096 or 0.3% size of file.

-    size_t base_length = base_output.length();

-    size_t modified_length = modified_output.length();

-    ptrdiff_t diff = base_length - modified_length;

-    if (diff < -200 || diff > 200) {

-      EXPECT_EQ(base_length, modified_length);

-    }

-

-    size_t changed_byte_count = 0;

-    for (size_t i = 0;  i < base_length && i < modified_length; ++i) {

-      changed_byte_count += (base_output[i] != modified_output[i]);

-    }

-

-    if (index > 60) {                     // Beyond the origin addresses ...

-      EXPECT_NE(0, changed_byte_count);   //   ... we expect some difference.

-    }

-    // Currently all changes are smaller than this number:

-    EXPECT_GE(45000u, changed_byte_count);

-  }

-}

-

-bool DecodeFuzzTest::TryAssemble(const std::string& buffer,

-                                 std::string* output) const {

-  courgette::EncodedProgram *encoded = NULL;

-  bool result = false;

-

-  courgette::SourceStreamSet sources;

-  bool can_get_source_streams = sources.Init(buffer.c_str(), buffer.length());

-  if (can_get_source_streams) {

-    const courgette::Status read_status =

-        ReadEncodedProgram(&sources, &encoded);

-    if (read_status == courgette::C_OK) {

-      courgette::SinkStream assembled;

-      const courgette::Status assemble_status = Assemble(encoded, &assembled);

-

-      if (assemble_status == courgette::C_OK) {

-        const void* assembled_buffer = assembled.Buffer();

-        size_t assembled_length = assembled.Length();

-

-        output->clear();

-        output->assign(reinterpret_cast<const char*>(assembled_buffer),

-                       assembled_length);

-        result = true;

-      }

-    }

-  }

-

-  DeleteEncodedProgram(encoded);

-

-  return result;

-}

-

-TEST_F(DecodeFuzzTest, All) {

-  FuzzExe("setup1.exe");

-}

-

-int main(int argc, char** argv) {

-  return TestSuite(argc, argv).Run();

-}

+// Copyright (c) 2009 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.
+
+// Fuzz testing for EncodedProgram serialized format and assembly.
+//
+// We would like some assurance that if an EncodedProgram is malformed we will
+// not crash.  The EncodedProgram could be malformed either due to malicious
+// attack to due to an error in patch generation.
+//
+// We try a lot of arbitrary modifications to the serialized form and make sure
+// that the outcome is not a crash.
+
+#include <string>
+
+#include "base/path_service.h"
+#include "base/file_util.h"
+#include "base/string_util.h"
+#include "base/test_suite.h"
+
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+class DecodeFuzzTest : public testing::Test {
+ public:
+  void FuzzExe(const char *) const;
+
+ private:
+  virtual void SetUp() {
+    PathService::Get(base::DIR_SOURCE_ROOT, &testdata_dir_);
+    testdata_dir_ = testdata_dir_.Append(L"courgette");
+    testdata_dir_ = testdata_dir_.Append(L"testdata");
+  }
+
+  virtual void TearDown() { }
+
+  void FuzzByte(const std::string& buffer, const std::string& output,
+                size_t index) const;
+  void FuzzBits(const std::string& buffer, const std::string& output,
+                size_t index, int bits_to_flip) const;
+
+  // Returns true if could assemble, false if rejected.
+  bool TryAssemble(const std::string& buffer, std::string* output) const;
+
+  // Returns contents of |file_name| as uninterprested bytes stored in a string.
+  std::string FileContents(const char* file_name) const;
+
+  // Full path name of testdata directory
+  FilePath testdata_dir_;
+};
+
+//  Reads a test file into a string.
+std::string DecodeFuzzTest::FileContents(const char* file_name) const {
+  FilePath file_path = testdata_dir_.AppendASCII(file_name);
+  std::string file_contents;
+  if (!file_util::ReadFileToString(file_path, &file_contents)) {
+    EXPECT_TRUE(!"Could not read test data");
+  }
+  return file_contents;
+}
+
+// Loads an executable and does fuzz testing in the serialized format.
+void DecodeFuzzTest::FuzzExe(const char* file_name) const {
+  std::string file1 = FileContents(file_name);
+
+  const void* original_buffer = file1.c_str();
+  size_t original_length = file1.size();
+
+  courgette::AssemblyProgram* program = NULL;
+  const courgette::Status parse_status =
+      courgette::ParseWin32X86PE(original_buffer, original_length, &program);
+  EXPECT_EQ(courgette::C_OK, parse_status);
+
+  courgette::EncodedProgram* encoded = NULL;
+
+  const courgette::Status encode_status = Encode(program, &encoded);
+  EXPECT_EQ(courgette::C_OK, encode_status);
+
+  DeleteAssemblyProgram(program);
+
+  courgette::SinkStreamSet sinks;
+  const courgette::Status write_status = WriteEncodedProgram(encoded, &sinks);
+  EXPECT_EQ(courgette::C_OK, write_status);
+
+  DeleteEncodedProgram(encoded);
+
+  courgette::SinkStream sink;
+  bool can_collect = sinks.CopyTo(&sink);
+  EXPECT_TRUE(can_collect);
+
+  size_t length = sink.Length();
+
+  std::string base_buffer(reinterpret_cast<const char*>(sink.Buffer()), length);
+  std::string base_output;
+  bool ok = TryAssemble(base_buffer, &base_output);
+  EXPECT_EQ(true, ok);
+
+  // Now we have a good serialized EncodedProgram in |base_buffer|. Time to
+  // fuzz.
+
+  // More intense fuzzing on the first part because it contains more control
+  // information like substeam lengths.
+  size_t position = 0;
+  for ( ;  position < 100 && position < length;  position += 1) {
+    FuzzByte(base_buffer, base_output, position);
+  }
+  // We would love to fuzz every position, but it takes too long.
+  for ( ;  position < length;  position += 900) {
+    FuzzByte(base_buffer, base_output, position);
+  }
+}
+
+// FuzzByte tries to break the EncodedProgram deserializer and assembler.  It
+// takes a good serialization of and EncodedProgram, flips some bits, and checks
+// that the behaviour is reasonable.  It has testing checks for unreasonable
+// behaviours.
+void DecodeFuzzTest::FuzzByte(const std::string& base_buffer,
+                              const std::string& base_output,
+                              size_t index) const {
+  printf("Fuzzing position %d\n", static_cast<int>(index));
+
+  // The following 10 values are a compromize between run time and coverage of
+  // the 255 'wrong' values at this byte position.
+
+  // 0xFF flips all the bits.
+  FuzzBits(base_buffer, base_output, index, 0xFF);
+  // 0x7F flips the most bits without changing Varint32 framing.
+  FuzzBits(base_buffer, base_output, index, 0x7F);
+  // These all flip one bit.
+  FuzzBits(base_buffer, base_output, index, 0x80);
+  FuzzBits(base_buffer, base_output, index, 0x40);
+  FuzzBits(base_buffer, base_output, index, 0x20);
+  FuzzBits(base_buffer, base_output, index, 0x10);
+  FuzzBits(base_buffer, base_output, index, 0x08);
+  FuzzBits(base_buffer, base_output, index, 0x04);
+  FuzzBits(base_buffer, base_output, index, 0x02);
+  FuzzBits(base_buffer, base_output, index, 0x01);
+}
+
+// FuzzBits tries to break the EncodedProgram deserializer and assembler.  It
+// takes a good serialization of and EncodedProgram, flips some bits, and checks
+// that the behaviour is reasonable.
+//
+// There are EXPECT calls to check for unreasonable behaviour.  These are
+// somewhat arbitrary in that the parameters cannot easily be derived from first
+// principles.  They may need updating as the serialized format evolves.
+void DecodeFuzzTest::FuzzBits(const std::string& base_buffer,
+                              const std::string& base_output,
+                              size_t index, int bits_to_flip) const {
+  std::string modified_buffer = base_buffer;
+  std::string modified_output;
+  modified_buffer[index] ^= bits_to_flip;
+
+  bool ok = TryAssemble(modified_buffer, &modified_output);
+
+  if (ok) {
+    // We normally expect TryAssemble to fail.  But sometimes it succeeds.
+    // What could have happened?  We changed one byte in the serialized form:
+    //
+    //  * If we changed one of the copied bytes, we would see a single byte
+    //    change in the output.
+    //  * If we changed an address table element, all the references to that
+    //    address would be different.
+    //  * If we changed a copy count, we would run out of data in some stream,
+    //    or leave data remaining, so should not be here.
+    //  * If we changed an origin address, it could affect all relocations based
+    //    off that address.  If no relocations were based off the address then
+    //    there will be no changes.
+    //  * If we changed an origin address, it could cause some abs32 relocs to
+    //    shift from one page to the next, changing the number and layout of
+    //    blocks in the base relocation table.
+
+    // Generated length could vary slightly due to base relocation table layout.
+    // In the worst case the number of base relocation blocks doubles, approx
+    // 12/4096 or 0.3% size of file.
+    size_t base_length = base_output.length();
+    size_t modified_length = modified_output.length();
+    ptrdiff_t diff = base_length - modified_length;
+    if (diff < -200 || diff > 200) {
+      EXPECT_EQ(base_length, modified_length);
+    }
+
+    size_t changed_byte_count = 0;
+    for (size_t i = 0;  i < base_length && i < modified_length; ++i) {
+      changed_byte_count += (base_output[i] != modified_output[i]);
+    }
+
+    if (index > 60) {                     // Beyond the origin addresses ...
+      EXPECT_NE(0, changed_byte_count);   //   ... we expect some difference.
+    }
+    // Currently all changes are smaller than this number:
+    EXPECT_GE(45000u, changed_byte_count);
+  }
+}
+
+bool DecodeFuzzTest::TryAssemble(const std::string& buffer,
+                                 std::string* output) const {
+  courgette::EncodedProgram *encoded = NULL;
+  bool result = false;
+
+  courgette::SourceStreamSet sources;
+  bool can_get_source_streams = sources.Init(buffer.c_str(), buffer.length());
+  if (can_get_source_streams) {
+    const courgette::Status read_status =
+        ReadEncodedProgram(&sources, &encoded);
+    if (read_status == courgette::C_OK) {
+      courgette::SinkStream assembled;
+      const courgette::Status assemble_status = Assemble(encoded, &assembled);
+
+      if (assemble_status == courgette::C_OK) {
+        const void* assembled_buffer = assembled.Buffer();
+        size_t assembled_length = assembled.Length();
+
+        output->clear();
+        output->assign(reinterpret_cast<const char*>(assembled_buffer),
+                       assembled_length);
+        result = true;
+      }
+    }
+  }
+
+  DeleteEncodedProgram(encoded);
+
+  return result;
+}
+
+TEST_F(DecodeFuzzTest, All) {
+  FuzzExe("setup1.exe");
+}
+
+int main(int argc, char** argv) {
+  return TestSuite(argc, argv).Run();
+}
diff --git a/third_party/courgette/encoded_program_unittest.cc b/courgette/encoded_program_unittest.cc
index 9b0025e..aedb838 100644
--- a/third_party/courgette/encoded_program_unittest.cc
+++ b/courgette/encoded_program_unittest.cc
@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/courgette/encoded_program.h"
+#include "courgette/encoded_program.h"
 
-#include "third_party/courgette/streams.h"
+#include "courgette/streams.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 TEST(EncodedProgramTest, Test) {
@@ -62,4 +62,3 @@ TEST(EncodedProgramTest, Test) {
 
   EXPECT_EQ(0, memcmp(assembled_buffer, golden, 8));
 }
-
diff --git a/third_party/courgette/ensemble.cc b/courgette/ensemble.cc
index 4c8f013..15bfb3e 100644
--- a/third_party/courgette/ensemble.cc
+++ b/courgette/ensemble.cc
@@ -1,102 +1,102 @@
-// Copyright (c) 2009 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.

-

-// *** File comments

-

-#include "third_party/courgette/ensemble.h"

-

-#include "base/basictypes.h"

-#include "base/logging.h"

-#include "base/string_util.h"

-

-#include "third_party/courgette/image_info.h"

-#include "third_party/courgette/region.h"

-#include "third_party/courgette/streams.h"

-#include "third_party/courgette/simple_delta.h"

-

-namespace courgette {

-

-Element::Element(Kind kind, Ensemble* ensemble, const Region& region)

-    : kind_(kind), ensemble_(ensemble), region_(region) {

-}

-

-std::string Element::Name() const {

-  return ensemble_->name() + "("

-      + IntToString(kind()) + ","

-      + Uint64ToString(offset_in_ensemble()) + ","

-      + Uint64ToString(region().length()) + ")";

-}

-

-// A subclass of Element that has a PEInfo.

-class ElementWinPE : public Element {

- public:

-  ElementWinPE(Kind kind, Ensemble* ensemble, const Region& region,

-               PEInfo* info)

-      : Element(kind, ensemble, region),

-        pe_info_(info) {

-  }

-

-  virtual PEInfo* GetPEInfo() const { return pe_info_; }

-

- protected:

-  ~ElementWinPE() { delete pe_info_; }

-

- private:

-  PEInfo* pe_info_;  // Owned by |this|.

-};

-

-// Scans the Ensemble's region, sniffing out Elements.  We assume that the

-// elements do not overlap.

-Status Ensemble::FindEmbeddedElements() {

-  size_t length = region_.length();

-  const uint8* start = region_.start();

-

-  size_t position = 0;

-  while (position < length) {

-    // Quick test; Windows executables begin with 'MZ'.

-    if (start[position] == 'M' &&

-        position + 1 < length && start[position + 1] == 'Z') {

-      courgette::PEInfo *info = new courgette::PEInfo();

-      info->Init(start + position, length - position);

-      if (info->ParseHeader()) {

-        Region region(start + position, info->length());

-

-        if (info->has_text_section()) {

-          Element* element = new ElementWinPE(Element::WIN32_X86_WITH_CODE,

-                                              this, region, info);

-          owned_elements_.push_back(element);

-          elements_.push_back(element);

-          position += region.length();

-          continue;

-        }

-

-        // If we had a clever transformation for resource-only executables we

-        // should identify the suitable elements here:

-        if (!info->has_text_section() && false) {

-          Element* element = new ElementWinPE(Element::WIN32_NOCODE,

-                                              this, region, info);

-          owned_elements_.push_back(element);

-          elements_.push_back(element);

-          position += region.length();

-          continue;

-        }

-      }

-      delete info;

-    }

-

-    // This is where to add new formats, e.g. Linux executables, Dalvik

-    // executables etc.

-

-    // No Element found at current position.

-    ++position;

-  }

-  return C_OK;

-}

-

-Ensemble::~Ensemble() {

-  for (size_t i = 0;  i < owned_elements_.size();  ++i)

-    delete owned_elements_[i];

-}

-

-}  // namespace

+// Copyright (c) 2009 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.
+
+// *** File comments
+
+#include "courgette/ensemble.h"
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+
+#include "courgette/image_info.h"
+#include "courgette/region.h"
+#include "courgette/streams.h"
+#include "courgette/simple_delta.h"
+
+namespace courgette {
+
+Element::Element(Kind kind, Ensemble* ensemble, const Region& region)
+    : kind_(kind), ensemble_(ensemble), region_(region) {
+}
+
+std::string Element::Name() const {
+  return ensemble_->name() + "("
+      + IntToString(kind()) + ","
+      + Uint64ToString(offset_in_ensemble()) + ","
+      + Uint64ToString(region().length()) + ")";
+}
+
+// A subclass of Element that has a PEInfo.
+class ElementWinPE : public Element {
+ public:
+  ElementWinPE(Kind kind, Ensemble* ensemble, const Region& region,
+               PEInfo* info)
+      : Element(kind, ensemble, region),
+        pe_info_(info) {
+  }
+
+  virtual PEInfo* GetPEInfo() const { return pe_info_; }
+
+ protected:
+  ~ElementWinPE() { delete pe_info_; }
+
+ private:
+  PEInfo* pe_info_;  // Owned by |this|.
+};
+
+// Scans the Ensemble's region, sniffing out Elements.  We assume that the
+// elements do not overlap.
+Status Ensemble::FindEmbeddedElements() {
+  size_t length = region_.length();
+  const uint8* start = region_.start();
+
+  size_t position = 0;
+  while (position < length) {
+    // Quick test; Windows executables begin with 'MZ'.
+    if (start[position] == 'M' &&
+        position + 1 < length && start[position + 1] == 'Z') {
+      courgette::PEInfo *info = new courgette::PEInfo();
+      info->Init(start + position, length - position);
+      if (info->ParseHeader()) {
+        Region region(start + position, info->length());
+
+        if (info->has_text_section()) {
+          Element* element = new ElementWinPE(Element::WIN32_X86_WITH_CODE,
+                                              this, region, info);
+          owned_elements_.push_back(element);
+          elements_.push_back(element);
+          position += region.length();
+          continue;
+        }
+
+        // If we had a clever transformation for resource-only executables we
+        // should identify the suitable elements here:
+        if (!info->has_text_section() && false) {
+          Element* element = new ElementWinPE(Element::WIN32_NOCODE,
+                                              this, region, info);
+          owned_elements_.push_back(element);
+          elements_.push_back(element);
+          position += region.length();
+          continue;
+        }
+      }
+      delete info;
+    }
+
+    // This is where to add new formats, e.g. Linux executables, Dalvik
+    // executables etc.
+
+    // No Element found at current position.
+    ++position;
+  }
+  return C_OK;
+}
+
+Ensemble::~Ensemble() {
+  for (size_t i = 0;  i < owned_elements_.size();  ++i)
+    delete owned_elements_[i];
+}
+
+}  // namespace
diff --git a/third_party/courgette/ensemble.h b/courgette/ensemble.h
index 7602c3f..6a58cb0 100644
--- a/third_party/courgette/ensemble.h
+++ b/courgette/ensemble.h
@@ -1,257 +1,257 @@
-// Copyright (c) 2009 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

-// transformation.

-//

-// This file declares all the main types involved in creating and applying a

-// patch with this structure.

-

-#ifndef COURGETTE_ENSEMBLE_H_

-#define COURGETTE_ENSEMBLE_H_

-

-#include <vector>

-#include <string>

-

-#include "base/basictypes.h"

-

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/region.h"

-#include "third_party/courgette/streams.h"

-

-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 };

-

-  virtual ~Element() {}

-

-  Kind 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);

-

- private:

-  Kind kind_;

-  Ensemble* ensemble_;

-  Region region_;

-

-  DISALLOW_COPY_AND_ASSIGN(Element);

-};

-

-

-class Ensemble {

- public:

-  Ensemble(const Region& region, const char* name)

-      : region_(region), name_(name) {}

-  ~Ensemble();

-

-  const Region& region() const { return region_; }

-  const std::string& name() const { return name_; }

-

-  // Scans the region to find Elements within the region().

-  Status FindEmbeddedElements();

-

-  // Returns the elements found by 'FindEmbeddedElements'.

-  const std::vector<Element*>& elements() const { return elements_; }

-

-

- private:

-  Region region_;       // The memory, owned by caller, containing the

-                        // Ensemble's data.

-  std::string name_;    // A debugging/logging name for the Ensemble.

-

-  std::vector<Element*> elements_;        // Embedded elements discovered.

-  std::vector<Element*> owned_elements_;  // For deallocation.

-

-  DISALLOW_COPY_AND_ASSIGN(Ensemble);

-};

-

-inline size_t Element::offset_in_ensemble() const {

-  return region().start() - ensemble_->region().start();

-}

-

-// The 'CourgettePatchFile' is class is a 'namespace' for the constants that

-// appear in a Courgette patch file.

-struct CourgettePatchFile {

-  //

-  // The Courgette patch format interleaves the data for N embedded Elements.

-  //

-  // Format of a patch file:

-  //  header:

-  //    magic

-  //    version

-  //    source-checksum

-  //    target-checksum

-  //  multiple-streams:

-  //    stream 0:

-  //      number-of-transformed-elements (N) - varint32

-  //      transformation-1-method-id

-  //      transformation-2-method-id

-  //      ...

-  //      transformation-1-initial-parameters

-  //      transformation-2-initial-parameters

-  //      ...

-  //    stream 1:

-  //      correction:

-  //        transformation-1-parameters

-  //        transformation-2-parameters

-  //        ...

-  //    stream 2:

-  //      correction:

-  //        transformed-element-1

-  //        transformed-element-2

-  //        ...

-  //    stream 3:

-  //      correction:

-  //        base-file

-  //        element-1

-  //        element-2

-  //        ...

-

-  static const uint32 kMagic = 'C' | ('o' << 8) | ('u' << 16);

-

-  static const uint32 kVersion = 20090320;

-

-  // Transformation method IDs.

-  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

-// element, for example, range of locations within the original ensemble that

-// correspond to the element.

-//

-// PredictTransformParameters, explained below.

-//

-// The two final steps are 'Transform' - to transform the element into a new

-// representation, and to 'Reform' - to transform from the new representation

-// back to the original form.

-//

-// The Transform step takes some parameters.  This allows the transform to be

-// customized to the particular element, or to receive some assistance in the

-// analysis required to perform the transform.  The transform parameters might

-// be extensive but mostly predicable, so preceeding Transform is a

-// PredictTransformParameters step.

-//

-class TransformationPatcher {

- public:

-  virtual ~TransformationPatcher() {}

-

-  // First step: provides parameters for the patching.  This would at a minimum

-  // identify the element within the ensemble being patched.

-  virtual Status Init(SourceStream* parameter_stream) = 0;

-

-  // Second step: predicts transform parameters.

-  virtual Status PredictTransformParameters(

-      SinkStreamSet* predicted_parameters) = 0;

-

-  // Third step: transforms element from original representation into alternate

-  // representation.

-  virtual Status Transform(SourceStreamSet* corrected_parameters,

-                           SinkStreamSet* transformed_element) = 0;

-

-  // Final step: transforms element back from alternate representation into

-  // original representation.

-  virtual Status Reform(SourceStreamSet* transformed_element,

-                        SinkStream* reformed_element) = 0;

-};

-

-// TransformationPatchGenerator is the interface which abstracts out the actual

-// transformation used (and adjustment used) when differentially compressing one

-// Element from the |new_ensemble| against a corresponding element in the

-// |old_ensemble|.

-//

-// This is not a pure interface.  There is a small amount of inheritance

-// implementation for the fields and actions common to all

-// TransformationPatchGenerators.

-//

-// When TransformationPatchGenerator is subclassed, there will be a

-// corresponding subclass of TransformationPatcher.

-//

-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;

-

-  // 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);

-

-  // Writes the desired parameters for the transform of the old element from the

-  // file representation to the alternate representation.

-  virtual Status CorrectedTransformParameters(SinkStreamSet* parameters) = 0;

-

-  // Writes both |old_element| and |new_element| in the new representation.

-  // |old_corrected_parameters| will match the |corrected_parameters| passed to

-  // the Transform method of the corresponding sublcass of

-  // TransformationPatcher.

-  //

-  // The output written to |old_transformed_element| must match exactly the

-  // output written by the Transform method of the corresponding subclass of

-  // TransformationPatcher.

-  virtual Status Transform(SourceStreamSet* old_corrected_parameters,

-                           SinkStreamSet* old_transformed_element,

-                           SinkStreamSet* new_transformed_element) = 0;

-

-  // Transforms the new transformed_element back from the alternate

-  // representation into the original file format.  This must match exactly the

-  // output that will be produced by the corresponding subclass of

-  // TransformationPatcher::Reform.  This method is not pure. The default

-  // implementation delegates to the patcher.

-  virtual Status Reform(SourceStreamSet* transformed_element,

-                        SinkStream* reformed_element);

-

- protected:

-  Element* old_element_;

-  Element* new_element_;

-  TransformationPatcher* patcher_;

-};

-

-}  // namespace

-#endif  // COURGETTE_ENSEMBLE_H_

+// Copyright (c) 2009 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
+// transformation.
+//
+// This file declares all the main types involved in creating and applying a
+// patch with this structure.
+
+#ifndef COURGETTE_ENSEMBLE_H_
+#define COURGETTE_ENSEMBLE_H_
+
+#include <vector>
+#include <string>
+
+#include "base/basictypes.h"
+
+#include "courgette/courgette.h"
+#include "courgette/region.h"
+#include "courgette/streams.h"
+
+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 };
+
+  virtual ~Element() {}
+
+  Kind 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);
+
+ private:
+  Kind kind_;
+  Ensemble* ensemble_;
+  Region region_;
+
+  DISALLOW_COPY_AND_ASSIGN(Element);
+};
+
+
+class Ensemble {
+ public:
+  Ensemble(const Region& region, const char* name)
+      : region_(region), name_(name) {}
+  ~Ensemble();
+
+  const Region& region() const { return region_; }
+  const std::string& name() const { return name_; }
+
+  // Scans the region to find Elements within the region().
+  Status FindEmbeddedElements();
+
+  // Returns the elements found by 'FindEmbeddedElements'.
+  const std::vector<Element*>& elements() const { return elements_; }
+
+
+ private:
+  Region region_;       // The memory, owned by caller, containing the
+                        // Ensemble's data.
+  std::string name_;    // A debugging/logging name for the Ensemble.
+
+  std::vector<Element*> elements_;        // Embedded elements discovered.
+  std::vector<Element*> owned_elements_;  // For deallocation.
+
+  DISALLOW_COPY_AND_ASSIGN(Ensemble);
+};
+
+inline size_t Element::offset_in_ensemble() const {
+  return region().start() - ensemble_->region().start();
+}
+
+// The 'CourgettePatchFile' is class is a 'namespace' for the constants that
+// appear in a Courgette patch file.
+struct CourgettePatchFile {
+  //
+  // The Courgette patch format interleaves the data for N embedded Elements.
+  //
+  // Format of a patch file:
+  //  header:
+  //    magic
+  //    version
+  //    source-checksum
+  //    target-checksum
+  //  multiple-streams:
+  //    stream 0:
+  //      number-of-transformed-elements (N) - varint32
+  //      transformation-1-method-id
+  //      transformation-2-method-id
+  //      ...
+  //      transformation-1-initial-parameters
+  //      transformation-2-initial-parameters
+  //      ...
+  //    stream 1:
+  //      correction:
+  //        transformation-1-parameters
+  //        transformation-2-parameters
+  //        ...
+  //    stream 2:
+  //      correction:
+  //        transformed-element-1
+  //        transformed-element-2
+  //        ...
+  //    stream 3:
+  //      correction:
+  //        base-file
+  //        element-1
+  //        element-2
+  //        ...
+
+  static const uint32 kMagic = 'C' | ('o' << 8) | ('u' << 16);
+
+  static const uint32 kVersion = 20090320;
+
+  // Transformation method IDs.
+  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
+// element, for example, range of locations within the original ensemble that
+// correspond to the element.
+//
+// PredictTransformParameters, explained below.
+//
+// The two final steps are 'Transform' - to transform the element into a new
+// representation, and to 'Reform' - to transform from the new representation
+// back to the original form.
+//
+// The Transform step takes some parameters.  This allows the transform to be
+// customized to the particular element, or to receive some assistance in the
+// analysis required to perform the transform.  The transform parameters might
+// be extensive but mostly predicable, so preceeding Transform is a
+// PredictTransformParameters step.
+//
+class TransformationPatcher {
+ public:
+  virtual ~TransformationPatcher() {}
+
+  // First step: provides parameters for the patching.  This would at a minimum
+  // identify the element within the ensemble being patched.
+  virtual Status Init(SourceStream* parameter_stream) = 0;
+
+  // Second step: predicts transform parameters.
+  virtual Status PredictTransformParameters(
+      SinkStreamSet* predicted_parameters) = 0;
+
+  // Third step: transforms element from original representation into alternate
+  // representation.
+  virtual Status Transform(SourceStreamSet* corrected_parameters,
+                           SinkStreamSet* transformed_element) = 0;
+
+  // Final step: transforms element back from alternate representation into
+  // original representation.
+  virtual Status Reform(SourceStreamSet* transformed_element,
+                        SinkStream* reformed_element) = 0;
+};
+
+// TransformationPatchGenerator is the interface which abstracts out the actual
+// transformation used (and adjustment used) when differentially compressing one
+// Element from the |new_ensemble| against a corresponding element in the
+// |old_ensemble|.
+//
+// This is not a pure interface.  There is a small amount of inheritance
+// implementation for the fields and actions common to all
+// TransformationPatchGenerators.
+//
+// When TransformationPatchGenerator is subclassed, there will be a
+// corresponding subclass of TransformationPatcher.
+//
+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;
+
+  // 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);
+
+  // Writes the desired parameters for the transform of the old element from the
+  // file representation to the alternate representation.
+  virtual Status CorrectedTransformParameters(SinkStreamSet* parameters) = 0;
+
+  // Writes both |old_element| and |new_element| in the new representation.
+  // |old_corrected_parameters| will match the |corrected_parameters| passed to
+  // the Transform method of the corresponding sublcass of
+  // TransformationPatcher.
+  //
+  // The output written to |old_transformed_element| must match exactly the
+  // output written by the Transform method of the corresponding subclass of
+  // TransformationPatcher.
+  virtual Status Transform(SourceStreamSet* old_corrected_parameters,
+                           SinkStreamSet* old_transformed_element,
+                           SinkStreamSet* new_transformed_element) = 0;
+
+  // Transforms the new transformed_element back from the alternate
+  // representation into the original file format.  This must match exactly the
+  // output that will be produced by the corresponding subclass of
+  // TransformationPatcher::Reform.  This method is not pure. The default
+  // implementation delegates to the patcher.
+  virtual Status Reform(SourceStreamSet* transformed_element,
+                        SinkStream* reformed_element);
+
+ protected:
+  Element* old_element_;
+  Element* new_element_;
+  TransformationPatcher* patcher_;
+};
+
+}  // namespace
+#endif  // COURGETTE_ENSEMBLE_H_
diff --git a/third_party/courgette/ensemble_apply.cc b/courgette/ensemble_apply.cc
index 7954ca4..5a9edfd4 100644
--- a/third_party/courgette/ensemble_apply.cc
+++ b/courgette/ensemble_apply.cc
@@ -1,412 +1,412 @@
-// Copyright (c) 2009 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.

-

-// This file contains the code to apply a Courgette patch.

-

-#include "third_party/courgette/ensemble.h"

-

-#include "base/basictypes.h"

-#include "base/file_util.h"

-#include "base/logging.h"

-

-#include "third_party/courgette/crc.h"

-#include "third_party/courgette/image_info.h"

-#include "third_party/courgette/region.h"

-#include "third_party/courgette/streams.h"

-#include "third_party/courgette/simple_delta.h"

-#include "third_party/courgette/win32_x86_patcher.h"

-

-namespace courgette {

-

-// EnsemblePatchApplication is all the logic and data required to apply the

-// multi-stage patch.

-class EnsemblePatchApplication {

- public:

-  EnsemblePatchApplication();

-  ~EnsemblePatchApplication();

-

-  Status ReadHeader(SourceStream* header_stream);

-

-  Status InitBase(const Region& region);

-

-  Status ValidateBase();

-

-  Status ReadInitialParameters(SourceStream* initial_parameters);

-

-  Status PredictTransformParameters(SinkStreamSet* predicted_parameters);

-

-  Status SubpatchTransformParameters(SinkStreamSet* prediction,

-                                     SourceStream* correction,

-                                     SourceStreamSet* corrected_parameters);

-

-  Status TransformUp(SourceStreamSet* parameters,

-                     SinkStreamSet* transformed_elements);

-

-  Status SubpatchTransformedElements(SinkStreamSet* elements,

-                                     SourceStream* correction,

-                                     SourceStreamSet* corrected_elements);

-

-  Status TransformDown(SourceStreamSet* transformed_elements,

-                       SinkStream* basic_elements);

-

-  Status SubpatchFinalOutput(SourceStream* original,

-                             SourceStream* correction,

-                             SinkStream* corrected_ensemble);

-

- private:

-  Status SubpatchStreamSets(SinkStreamSet* predicted_items,

-                            SourceStream* correction,

-                            SourceStreamSet* corrected_items,

-                            SinkStream* corrected_items_storage);

-

-  Region base_region_;       // Location of in-memory copy of 'old' version.

-

-  uint32 source_checksum_;

-  uint32 target_checksum_;

-

-  std::vector<TransformationPatcher*> patchers_;

-

-  SinkStream corrected_parameters_storage_;

-  SinkStream corrected_elements_storage_;

-

-  DISALLOW_COPY_AND_ASSIGN(EnsemblePatchApplication);

-};

-

-EnsemblePatchApplication::EnsemblePatchApplication()

-    : source_checksum_(0), target_checksum_(0) {

-}

-

-EnsemblePatchApplication::~EnsemblePatchApplication() {

-  for (size_t i = 0;  i < patchers_.size();  ++i) {

-    delete patchers_[i];

-  }

-}

-

-Status EnsemblePatchApplication::ReadHeader(SourceStream* header_stream) {

-  uint32 magic;

-  if (!header_stream->ReadVarint32(&magic))

-    return C_BAD_ENSEMBLE_MAGIC;

-

-  if (magic != CourgettePatchFile::kMagic)

-    return C_BAD_ENSEMBLE_MAGIC;

-

-  uint32 version;

-  if (!header_stream->ReadVarint32(&version))

-    return C_BAD_ENSEMBLE_VERSION;

-

-  if (version != CourgettePatchFile::kVersion)

-    return C_BAD_ENSEMBLE_VERSION;

-

-  if (!header_stream->ReadVarint32(&source_checksum_))

-    return C_BAD_ENSEMBLE_HEADER;

-

-  if (!header_stream->ReadVarint32(&target_checksum_))

-    return C_BAD_ENSEMBLE_HEADER;

-

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::InitBase(const Region& region) {

-  base_region_.assign(region);

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::ValidateBase() {

-  uint32 checksum = CalculateCrc(base_region_.start(), base_region_.length());

-  if (source_checksum_ != checksum)

-    return C_BAD_ENSEMBLE_CRC;

-

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::ReadInitialParameters(

-    SourceStream* transformation_parameters) {

-  uint32 number_of_transformations = 0;

-  if (!transformation_parameters->ReadVarint32(&number_of_transformations))

-    return C_BAD_ENSEMBLE_HEADER;

-

-  for (size_t i = 0;  i < number_of_transformations;  ++i) {

-    uint32 kind;

-    if (!transformation_parameters->ReadVarint32(&kind))

-      return C_BAD_ENSEMBLE_HEADER;

-

-    if (kind == CourgettePatchFile::T_COURGETTE_WIN32_X86) {

-      TransformationPatcher* patcher =

-          new CourgetteWin32X86Patcher(base_region_);

-      patchers_.push_back(patcher);

-    } else {

-      return C_BAD_ENSEMBLE_HEADER;

-    }

-  }

-

-  for (size_t i = 0;  i < patchers_.size();  ++i) {

-    Status status = patchers_[i]->Init(transformation_parameters);

-    if (status != C_OK)

-      return status;

-  }

-

-  // All transformation_parameters should have been consumed by the above loop.

-  if (!transformation_parameters->Empty())

-    return C_BAD_ENSEMBLE_HEADER;

-

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::PredictTransformParameters(

-    SinkStreamSet* all_predicted_parameters) {

-  for (size_t i = 0;  i < patchers_.size();  ++i) {

-    SinkStreamSet single_predicted_parameters;

-    Status status =

-        patchers_[i]->PredictTransformParameters(&single_predicted_parameters);

-    if (status != C_OK)

-      return status;

-    if (!all_predicted_parameters->WriteSet(&single_predicted_parameters))

-      return C_STREAM_ERROR;

-  }

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::SubpatchTransformParameters(

-    SinkStreamSet* predicted_parameters,

-    SourceStream* correction,

-    SourceStreamSet* corrected_parameters) {

-  return SubpatchStreamSets(predicted_parameters,

-                            correction,

-                            corrected_parameters,

-                            &corrected_parameters_storage_);

-}

-

-Status EnsemblePatchApplication::TransformUp(

-    SourceStreamSet* parameters,

-    SinkStreamSet* transformed_elements) {

-  for (size_t i = 0;  i < patchers_.size();  ++i) {

-    SourceStreamSet single_parameters;

-    if (!parameters->ReadSet(&single_parameters))

-      return C_STREAM_ERROR;

-    SinkStreamSet single_transformed_element;

-    Status status = patchers_[i]->Transform(&single_parameters,

-                                            &single_transformed_element);

-    if (status != C_OK)

-      return status;

-    if (!single_parameters.Empty())

-      return C_STREAM_NOT_CONSUMED;

-    if (!transformed_elements->WriteSet(&single_transformed_element))

-      return C_STREAM_ERROR;

-  }

-

-  if (!parameters->Empty())

-    return C_STREAM_NOT_CONSUMED;

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::SubpatchTransformedElements(

-    SinkStreamSet* predicted_elements,

-    SourceStream* correction,

-    SourceStreamSet* corrected_elements) {

-  return SubpatchStreamSets(predicted_elements,

-                            correction,

-                            corrected_elements,

-                            &corrected_elements_storage_);

-}

-

-Status EnsemblePatchApplication::TransformDown(

-    SourceStreamSet* transformed_elements,

-    SinkStream* basic_elements) {

-  // Construct blob of original input followed by reformed elements.

-

-  // The original input:

-  basic_elements->Write(base_region_.start(), base_region_.length());

-

-  for (size_t i = 0;  i < patchers_.size();  ++i) {

-    SourceStreamSet single_corrected_element;

-    if (!transformed_elements->ReadSet(&single_corrected_element))

-      return C_STREAM_ERROR;

-    Status status = patchers_[i]->Reform(&single_corrected_element,

-                                         basic_elements);

-    if (status != C_OK)

-      return status;

-    if (!single_corrected_element.Empty())

-      return C_STREAM_NOT_CONSUMED;

-  }

-

-  if (!transformed_elements->Empty())

-    return C_STREAM_NOT_CONSUMED;

-

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::SubpatchFinalOutput(

-    SourceStream* original,

-    SourceStream* correction,

-    SinkStream* corrected_ensemble) {

-  Status delta_status = ApplySimpleDelta(original, correction,

-                                         corrected_ensemble);

-  if (delta_status != C_OK)

-    return delta_status;

-

-  if (CalculateCrc(corrected_ensemble->Buffer(),

-                   corrected_ensemble->Length()) != target_checksum_)

-    return C_BAD_ENSEMBLE_CRC;

-

-  return C_OK;

-}

-

-Status EnsemblePatchApplication::SubpatchStreamSets(

-    SinkStreamSet* predicted_items,

-    SourceStream* correction,

-    SourceStreamSet* corrected_items,

-    SinkStream* corrected_items_storage) {

-  SinkStream linearized_predicted_items;

-  if (!predicted_items->CopyTo(&linearized_predicted_items))

-    return C_STREAM_ERROR;

-

-  SourceStream prediction;

-  prediction.Init(linearized_predicted_items);

-

-  Status status = ApplySimpleDelta(&prediction,

-                                   correction,

-                                   corrected_items_storage);

-  if (status != C_OK)

-    return status;

-

-  if (!corrected_items->Init(corrected_items_storage->Buffer(),

-                             corrected_items_storage->Length()))

-    return C_STREAM_ERROR;

-

-  return C_OK;

-}

-

-Status ApplyEnsemblePatch(SourceStream* base,

-                          SourceStream* patch,

-                          SinkStream* output) {

-  Status status;

-  EnsemblePatchApplication patch_process;

-

-  status = patch_process.ReadHeader(patch);

-  if (status != C_OK)

-    return status;

-

-  status = patch_process.InitBase(Region(base->Buffer(), base->Remaining()));

-  if (status != C_OK)

-    return status;

-

-  status = patch_process.ValidateBase();

-  if (status != C_OK)

-    return status;

-

-  // The rest of the patch stream is a StreamSet.

-  SourceStreamSet patch_streams;

-  patch_streams.Init(patch);

-

-  SourceStream* transformation_descriptions     = patch_streams.stream(0);

-  SourceStream* parameter_correction            = patch_streams.stream(1);

-  SourceStream* transformed_elements_correction = patch_streams.stream(2);

-  SourceStream* ensemble_correction             = patch_streams.stream(3);

-

-  status = patch_process.ReadInitialParameters(transformation_descriptions);

-  if (status != C_OK)

-    return status;

-

-  SinkStreamSet predicted_parameters;

-  status = patch_process.PredictTransformParameters(&predicted_parameters);

-  if (status != C_OK)

-    return status;

-

-  SourceStreamSet corrected_parameters;

-  status = patch_process.SubpatchTransformParameters(&predicted_parameters,

-                                                     parameter_correction,

-                                                     &corrected_parameters);

-  if (status != C_OK)

-    return status;

-

-  SinkStreamSet transformed_elements;

-  status = patch_process.TransformUp(&corrected_parameters,

-                                     &transformed_elements);

-  if (status != C_OK)

-    return status;

-

-  SourceStreamSet corrected_transformed_elements;

-  status = patch_process.SubpatchTransformedElements(

-          &transformed_elements,

-          transformed_elements_correction,

-          &corrected_transformed_elements);

-  if (status != C_OK)

-    return status;

-

-  SinkStream original_ensemble_and_corrected_base_elements;

-  status = patch_process.TransformDown(

-      &corrected_transformed_elements,

-      &original_ensemble_and_corrected_base_elements);

-  if (status != C_OK)

-    return status;

-

-  SourceStream final_patch_prediction;

-  final_patch_prediction.Init(original_ensemble_and_corrected_base_elements);

-  status = patch_process.SubpatchFinalOutput(&final_patch_prediction,

-                                             ensemble_correction, output);

-  if (status != C_OK)

-    return status;

-

-  return C_OK;

-}

-

-Status ApplyEnsemblePatch(const wchar_t* old_file_name,

-                          const wchar_t* patch_file_name,

-                          const wchar_t* new_file_name) {

-  Status status;

-

-  // First read enough of the patch file to validate the header is well-formed.

-  // A few varint32 numbers should fit in 100.

-  FilePath patch_file_path(patch_file_name);

-  const int BIG_ENOUGH_FOR_HEADER = 100;

-  char buffer[BIG_ENOUGH_FOR_HEADER];

-  int read_count =

-      file_util::ReadFile(patch_file_path, buffer, sizeof(buffer));

-  if (read_count < 0)

-    return C_READ_OPEN_ERROR;

-

-  // 'Dry-run' the first step of the patch process to validate format of header.

-  SourceStream patch_header_stream;

-  patch_header_stream.Init(buffer, read_count);

-  EnsemblePatchApplication patch_process;

-  status = patch_process.ReadHeader(&patch_header_stream);

-  if (status != C_OK)

-    return status;

-

-  // Header smells good so read the whole patch file for real.

-  std::string patch_file_buffer;

-  if (!file_util::ReadFileToString(patch_file_path, &patch_file_buffer))

-    return C_READ_ERROR;

-

-  // Read the old_file.

-  FilePath old_file_path(old_file_name);

-  std::string old_file_buffer;

-  if (!file_util::ReadFileToString(old_file_path, &old_file_buffer))

-    return C_READ_ERROR;

-

-  // Apply patch on streams.

-  SourceStream old_source_stream;

-  SourceStream patch_source_stream;

-  old_source_stream.Init(old_file_buffer);

-  patch_source_stream.Init(patch_file_buffer);

-  SinkStream new_sink_stream;

-  status = ApplyEnsemblePatch(&old_source_stream, &patch_source_stream,

-                              &new_sink_stream);

-

-  // Write the patched data to |new_file_name|.

-  FilePath new_file_path(new_file_name);

-  int written =

-      file_util::WriteFile(

-          new_file_path,

-          reinterpret_cast<const char*>(new_sink_stream.Buffer()),

-          new_sink_stream.Length());

-  if (written == -1)

-    return C_WRITE_OPEN_ERROR;

-  if (written != new_sink_stream.Length())

-    return C_WRITE_ERROR;

-

-  return C_OK;

-}

-

-}  // namespace

+// Copyright (c) 2009 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.
+
+// This file contains the code to apply a Courgette patch.
+
+#include "courgette/ensemble.h"
+
+#include "base/basictypes.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+
+#include "courgette/crc.h"
+#include "courgette/image_info.h"
+#include "courgette/region.h"
+#include "courgette/streams.h"
+#include "courgette/simple_delta.h"
+#include "courgette/win32_x86_patcher.h"
+
+namespace courgette {
+
+// EnsemblePatchApplication is all the logic and data required to apply the
+// multi-stage patch.
+class EnsemblePatchApplication {
+ public:
+  EnsemblePatchApplication();
+  ~EnsemblePatchApplication();
+
+  Status ReadHeader(SourceStream* header_stream);
+
+  Status InitBase(const Region& region);
+
+  Status ValidateBase();
+
+  Status ReadInitialParameters(SourceStream* initial_parameters);
+
+  Status PredictTransformParameters(SinkStreamSet* predicted_parameters);
+
+  Status SubpatchTransformParameters(SinkStreamSet* prediction,
+                                     SourceStream* correction,
+                                     SourceStreamSet* corrected_parameters);
+
+  Status TransformUp(SourceStreamSet* parameters,
+                     SinkStreamSet* transformed_elements);
+
+  Status SubpatchTransformedElements(SinkStreamSet* elements,
+                                     SourceStream* correction,
+                                     SourceStreamSet* corrected_elements);
+
+  Status TransformDown(SourceStreamSet* transformed_elements,
+                       SinkStream* basic_elements);
+
+  Status SubpatchFinalOutput(SourceStream* original,
+                             SourceStream* correction,
+                             SinkStream* corrected_ensemble);
+
+ private:
+  Status SubpatchStreamSets(SinkStreamSet* predicted_items,
+                            SourceStream* correction,
+                            SourceStreamSet* corrected_items,
+                            SinkStream* corrected_items_storage);
+
+  Region base_region_;       // Location of in-memory copy of 'old' version.
+
+  uint32 source_checksum_;
+  uint32 target_checksum_;
+
+  std::vector<TransformationPatcher*> patchers_;
+
+  SinkStream corrected_parameters_storage_;
+  SinkStream corrected_elements_storage_;
+
+  DISALLOW_COPY_AND_ASSIGN(EnsemblePatchApplication);
+};
+
+EnsemblePatchApplication::EnsemblePatchApplication()
+    : source_checksum_(0), target_checksum_(0) {
+}
+
+EnsemblePatchApplication::~EnsemblePatchApplication() {
+  for (size_t i = 0;  i < patchers_.size();  ++i) {
+    delete patchers_[i];
+  }
+}
+
+Status EnsemblePatchApplication::ReadHeader(SourceStream* header_stream) {
+  uint32 magic;
+  if (!header_stream->ReadVarint32(&magic))
+    return C_BAD_ENSEMBLE_MAGIC;
+
+  if (magic != CourgettePatchFile::kMagic)
+    return C_BAD_ENSEMBLE_MAGIC;
+
+  uint32 version;
+  if (!header_stream->ReadVarint32(&version))
+    return C_BAD_ENSEMBLE_VERSION;
+
+  if (version != CourgettePatchFile::kVersion)
+    return C_BAD_ENSEMBLE_VERSION;
+
+  if (!header_stream->ReadVarint32(&source_checksum_))
+    return C_BAD_ENSEMBLE_HEADER;
+
+  if (!header_stream->ReadVarint32(&target_checksum_))
+    return C_BAD_ENSEMBLE_HEADER;
+
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::InitBase(const Region& region) {
+  base_region_.assign(region);
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::ValidateBase() {
+  uint32 checksum = CalculateCrc(base_region_.start(), base_region_.length());
+  if (source_checksum_ != checksum)
+    return C_BAD_ENSEMBLE_CRC;
+
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::ReadInitialParameters(
+    SourceStream* transformation_parameters) {
+  uint32 number_of_transformations = 0;
+  if (!transformation_parameters->ReadVarint32(&number_of_transformations))
+    return C_BAD_ENSEMBLE_HEADER;
+
+  for (size_t i = 0;  i < number_of_transformations;  ++i) {
+    uint32 kind;
+    if (!transformation_parameters->ReadVarint32(&kind))
+      return C_BAD_ENSEMBLE_HEADER;
+
+    if (kind == CourgettePatchFile::T_COURGETTE_WIN32_X86) {
+      TransformationPatcher* patcher =
+          new CourgetteWin32X86Patcher(base_region_);
+      patchers_.push_back(patcher);
+    } else {
+      return C_BAD_ENSEMBLE_HEADER;
+    }
+  }
+
+  for (size_t i = 0;  i < patchers_.size();  ++i) {
+    Status status = patchers_[i]->Init(transformation_parameters);
+    if (status != C_OK)
+      return status;
+  }
+
+  // All transformation_parameters should have been consumed by the above loop.
+  if (!transformation_parameters->Empty())
+    return C_BAD_ENSEMBLE_HEADER;
+
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::PredictTransformParameters(
+    SinkStreamSet* all_predicted_parameters) {
+  for (size_t i = 0;  i < patchers_.size();  ++i) {
+    SinkStreamSet single_predicted_parameters;
+    Status status =
+        patchers_[i]->PredictTransformParameters(&single_predicted_parameters);
+    if (status != C_OK)
+      return status;
+    if (!all_predicted_parameters->WriteSet(&single_predicted_parameters))
+      return C_STREAM_ERROR;
+  }
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::SubpatchTransformParameters(
+    SinkStreamSet* predicted_parameters,
+    SourceStream* correction,
+    SourceStreamSet* corrected_parameters) {
+  return SubpatchStreamSets(predicted_parameters,
+                            correction,
+                            corrected_parameters,
+                            &corrected_parameters_storage_);
+}
+
+Status EnsemblePatchApplication::TransformUp(
+    SourceStreamSet* parameters,
+    SinkStreamSet* transformed_elements) {
+  for (size_t i = 0;  i < patchers_.size();  ++i) {
+    SourceStreamSet single_parameters;
+    if (!parameters->ReadSet(&single_parameters))
+      return C_STREAM_ERROR;
+    SinkStreamSet single_transformed_element;
+    Status status = patchers_[i]->Transform(&single_parameters,
+                                            &single_transformed_element);
+    if (status != C_OK)
+      return status;
+    if (!single_parameters.Empty())
+      return C_STREAM_NOT_CONSUMED;
+    if (!transformed_elements->WriteSet(&single_transformed_element))
+      return C_STREAM_ERROR;
+  }
+
+  if (!parameters->Empty())
+    return C_STREAM_NOT_CONSUMED;
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::SubpatchTransformedElements(
+    SinkStreamSet* predicted_elements,
+    SourceStream* correction,
+    SourceStreamSet* corrected_elements) {
+  return SubpatchStreamSets(predicted_elements,
+                            correction,
+                            corrected_elements,
+                            &corrected_elements_storage_);
+}
+
+Status EnsemblePatchApplication::TransformDown(
+    SourceStreamSet* transformed_elements,
+    SinkStream* basic_elements) {
+  // Construct blob of original input followed by reformed elements.
+
+  // The original input:
+  basic_elements->Write(base_region_.start(), base_region_.length());
+
+  for (size_t i = 0;  i < patchers_.size();  ++i) {
+    SourceStreamSet single_corrected_element;
+    if (!transformed_elements->ReadSet(&single_corrected_element))
+      return C_STREAM_ERROR;
+    Status status = patchers_[i]->Reform(&single_corrected_element,
+                                         basic_elements);
+    if (status != C_OK)
+      return status;
+    if (!single_corrected_element.Empty())
+      return C_STREAM_NOT_CONSUMED;
+  }
+
+  if (!transformed_elements->Empty())
+    return C_STREAM_NOT_CONSUMED;
+
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::SubpatchFinalOutput(
+    SourceStream* original,
+    SourceStream* correction,
+    SinkStream* corrected_ensemble) {
+  Status delta_status = ApplySimpleDelta(original, correction,
+                                         corrected_ensemble);
+  if (delta_status != C_OK)
+    return delta_status;
+
+  if (CalculateCrc(corrected_ensemble->Buffer(),
+                   corrected_ensemble->Length()) != target_checksum_)
+    return C_BAD_ENSEMBLE_CRC;
+
+  return C_OK;
+}
+
+Status EnsemblePatchApplication::SubpatchStreamSets(
+    SinkStreamSet* predicted_items,
+    SourceStream* correction,
+    SourceStreamSet* corrected_items,
+    SinkStream* corrected_items_storage) {
+  SinkStream linearized_predicted_items;
+  if (!predicted_items->CopyTo(&linearized_predicted_items))
+    return C_STREAM_ERROR;
+
+  SourceStream prediction;
+  prediction.Init(linearized_predicted_items);
+
+  Status status = ApplySimpleDelta(&prediction,
+                                   correction,
+                                   corrected_items_storage);
+  if (status != C_OK)
+    return status;
+
+  if (!corrected_items->Init(corrected_items_storage->Buffer(),
+                             corrected_items_storage->Length()))
+    return C_STREAM_ERROR;
+
+  return C_OK;
+}
+
+Status ApplyEnsemblePatch(SourceStream* base,
+                          SourceStream* patch,
+                          SinkStream* output) {
+  Status status;
+  EnsemblePatchApplication patch_process;
+
+  status = patch_process.ReadHeader(patch);
+  if (status != C_OK)
+    return status;
+
+  status = patch_process.InitBase(Region(base->Buffer(), base->Remaining()));
+  if (status != C_OK)
+    return status;
+
+  status = patch_process.ValidateBase();
+  if (status != C_OK)
+    return status;
+
+  // The rest of the patch stream is a StreamSet.
+  SourceStreamSet patch_streams;
+  patch_streams.Init(patch);
+
+  SourceStream* transformation_descriptions     = patch_streams.stream(0);
+  SourceStream* parameter_correction            = patch_streams.stream(1);
+  SourceStream* transformed_elements_correction = patch_streams.stream(2);
+  SourceStream* ensemble_correction             = patch_streams.stream(3);
+
+  status = patch_process.ReadInitialParameters(transformation_descriptions);
+  if (status != C_OK)
+    return status;
+
+  SinkStreamSet predicted_parameters;
+  status = patch_process.PredictTransformParameters(&predicted_parameters);
+  if (status != C_OK)
+    return status;
+
+  SourceStreamSet corrected_parameters;
+  status = patch_process.SubpatchTransformParameters(&predicted_parameters,
+                                                     parameter_correction,
+                                                     &corrected_parameters);
+  if (status != C_OK)
+    return status;
+
+  SinkStreamSet transformed_elements;
+  status = patch_process.TransformUp(&corrected_parameters,
+                                     &transformed_elements);
+  if (status != C_OK)
+    return status;
+
+  SourceStreamSet corrected_transformed_elements;
+  status = patch_process.SubpatchTransformedElements(
+          &transformed_elements,
+          transformed_elements_correction,
+          &corrected_transformed_elements);
+  if (status != C_OK)
+    return status;
+
+  SinkStream original_ensemble_and_corrected_base_elements;
+  status = patch_process.TransformDown(
+      &corrected_transformed_elements,
+      &original_ensemble_and_corrected_base_elements);
+  if (status != C_OK)
+    return status;
+
+  SourceStream final_patch_prediction;
+  final_patch_prediction.Init(original_ensemble_and_corrected_base_elements);
+  status = patch_process.SubpatchFinalOutput(&final_patch_prediction,
+                                             ensemble_correction, output);
+  if (status != C_OK)
+    return status;
+
+  return C_OK;
+}
+
+Status ApplyEnsemblePatch(const wchar_t* old_file_name,
+                          const wchar_t* patch_file_name,
+                          const wchar_t* new_file_name) {
+  Status status;
+
+  // First read enough of the patch file to validate the header is well-formed.
+  // A few varint32 numbers should fit in 100.
+  FilePath patch_file_path(patch_file_name);
+  const int BIG_ENOUGH_FOR_HEADER = 100;
+  char buffer[BIG_ENOUGH_FOR_HEADER];
+  int read_count =
+      file_util::ReadFile(patch_file_path, buffer, sizeof(buffer));
+  if (read_count < 0)
+    return C_READ_OPEN_ERROR;
+
+  // 'Dry-run' the first step of the patch process to validate format of header.
+  SourceStream patch_header_stream;
+  patch_header_stream.Init(buffer, read_count);
+  EnsemblePatchApplication patch_process;
+  status = patch_process.ReadHeader(&patch_header_stream);
+  if (status != C_OK)
+    return status;
+
+  // Header smells good so read the whole patch file for real.
+  std::string patch_file_buffer;
+  if (!file_util::ReadFileToString(patch_file_path, &patch_file_buffer))
+    return C_READ_ERROR;
+
+  // Read the old_file.
+  FilePath old_file_path(old_file_name);
+  std::string old_file_buffer;
+  if (!file_util::ReadFileToString(old_file_path, &old_file_buffer))
+    return C_READ_ERROR;
+
+  // Apply patch on streams.
+  SourceStream old_source_stream;
+  SourceStream patch_source_stream;
+  old_source_stream.Init(old_file_buffer);
+  patch_source_stream.Init(patch_file_buffer);
+  SinkStream new_sink_stream;
+  status = ApplyEnsemblePatch(&old_source_stream, &patch_source_stream,
+                              &new_sink_stream);
+
+  // Write the patched data to |new_file_name|.
+  FilePath new_file_path(new_file_name);
+  int written =
+      file_util::WriteFile(
+          new_file_path,
+          reinterpret_cast<const char*>(new_sink_stream.Buffer()),
+          new_sink_stream.Length());
+  if (written == -1)
+    return C_WRITE_OPEN_ERROR;
+  if (written != new_sink_stream.Length())
+    return C_WRITE_ERROR;
+
+  return C_OK;
+}
+
+}  // namespace
diff --git a/third_party/courgette/ensemble_create.cc b/courgette/ensemble_create.cc
index 4d64f1c..6e64474 100644
--- a/third_party/courgette/ensemble_create.cc
+++ b/courgette/ensemble_create.cc
@@ -1,382 +1,382 @@
-// Copyright (c) 2009 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.

-

-// This file contains the code to create the patch.

-

-

-#include "third_party/courgette/ensemble.h"

-

-#include <vector>

-#include <limits>

-

-#include "base/basictypes.h"

-#include "base/logging.h"

-#include "base/time.h"

-

-#include "third_party/courgette/bsdiff.h"

-#include "third_party/courgette/crc.h"

-#include "third_party/courgette/difference_estimator.h"

-#include "third_party/courgette/image_info.h"

-#include "third_party/courgette/streams.h"

-#include "third_party/courgette/region.h"

-#include "third_party/courgette/simple_delta.h"

-

-#include "third_party/courgette/win32_x86_patcher.h"

-#include "third_party/courgette/win32_x86_generator.h"

-

-namespace courgette {

-

-TransformationPatchGenerator::TransformationPatchGenerator(

-    Element* old_element,

-    Element* new_element,

-    TransformationPatcher* patcher)

-    : old_element_(old_element),

-      new_element_(new_element),

-      patcher_(patcher) {

-}

-

-TransformationPatchGenerator::~TransformationPatchGenerator() {

-  delete patcher_;

-}

-

-// The default implementation of PredictTransformParameters delegates to the

-// patcher.

-Status TransformationPatchGenerator::PredictTransformParameters(

-    SinkStreamSet* prediction) {

-  return patcher_->PredictTransformParameters(prediction);

-}

-

-// The default implementation of Reform delegates to the patcher.

-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;

-  }

-}

-

-// FindGenerators finds TransformationPatchGenerators for the elements of

-// |new_ensemble|.  For each element of |new_ensemble| we find the closest

-// matching element from |old_ensemble| and use that as the basis for

-// differential compression.  The elements have to be the same kind so as to

-// support transformation into the same kind of 'new representation'.

-//

-Status FindGenerators(Ensemble* old_ensemble, Ensemble* new_ensemble,

-                      std::vector<TransformationPatchGenerator*>* generators) {

-  base::Time start_find_time = base::Time::Now();

-  old_ensemble->FindEmbeddedElements();

-  new_ensemble->FindEmbeddedElements();

-  LOG(INFO) << "done FindEmbeddedElements "

-            << (base::Time::Now() - start_find_time).InSecondsF();

-

-  std::vector<Element*> old_elements(old_ensemble->elements());

-  std::vector<Element*> new_elements(new_ensemble->elements());

-

-  LOG(INFO) << "old has " << old_elements.size() << " elements";

-  LOG(INFO) << "new has " << new_elements.size() << " elements";

-

-  DifferenceEstimator difference_estimator;

-  std::vector<DifferenceEstimator::Base*> bases;

-

-  base::Time start_bases_time = base::Time::Now();

-  for (size_t i = 0;  i < old_elements.size();  ++i) {

-    bases.push_back(

-        difference_estimator.MakeBase(old_elements[i]->region()));

-  }

-  LOG(INFO) << "done make bases "

-            << (base::Time::Now() - start_bases_time).InSecondsF()

-            << "s";

-

-  for (size_t new_index = 0;  new_index < new_elements.size();  ++new_index) {

-    Element* new_element = new_elements[new_index];

-    DifferenceEstimator::Subject* new_subject =

-        difference_estimator.MakeSubject(new_element->region());

-

-    // Search through old elements to find the best match.

-    //

-    // TODO(sra): This is O(N x M), i.e. O(N^2) since old_ensemble and

-    // new_ensemble probably have a very similar structure.  We can make the

-    // search faster by making the comparison provided by DifferenceEstimator

-    // more nuanced, returning early if the measured difference is greater than

-    // the current best.  This will be most effective if we can arrange that the

-    // first elements we try to match are likely the 'right' ones.  We could

-    // prioritize elements that are of a similar size or similar position in the

-    // sequence of elements.

-    //

-    Element* best_old_element = NULL;

-    size_t best_difference = std::numeric_limits<size_t>::max();

-    for (size_t old_index = 0;  old_index < old_elements.size();  ++old_index) {

-      Element* old_element = old_elements[old_index];

-      // Elements of different kinds are incompatible.

-      if (old_element->kind() != new_element->kind())

-        continue;

-

-      base::Time start_compare = base::Time::Now();

-      DifferenceEstimator::Base* old_base = bases[old_index];

-      size_t difference = difference_estimator.Measure(old_base, new_subject);

-

-      LOG(INFO) << "Compare " << old_element->Name()

-                << " to " << new_element->Name()

-                << " --> " << difference

-                << " in " << (base::Time::Now() - start_compare).InSecondsF()

-                << "s";

-      if (difference == 0) {

-        LOG(INFO) << "Skip " << new_element->Name()

-                  << " - identical to " << old_element->Name();

-        best_difference = 0;

-        best_old_element = NULL;

-        break;

-      }

-      if (difference < best_difference) {

-        best_difference = difference;

-        best_old_element = old_element;

-      }

-    }

-

-    if (best_old_element) {

-      LOG(INFO) << "Matched " << best_old_element->Name()

-                << " to " << new_element->Name()

-                << " --> " << best_difference;

-      TransformationPatchGenerator* generator =

-          MakeGenerator(best_old_element, new_element);

-      if (generator)

-        generators->push_back(generator);

-    }

-  }

-

-  LOG(INFO) << "done FindGenerators "

-            << "found " << generators->size() << " in "

-            << (base::Time::Now() - start_find_time).InSecondsF() << "s";

-

-  return C_OK;

-}

-

-void FreeGenerators(std::vector<TransformationPatchGenerator*>* generators) {

-  for (size_t i = 0;  i < generators->size();  ++i) {

-    delete (*generators)[i];

-  }

-  generators->clear();

-}

-

-////////////////////////////////////////////////////////////////////////////////

-

-Status GenerateEnsemblePatch(SourceStream* base,

-                             SourceStream* update,

-                             SinkStream* final_patch) {

-  Region old_region(base->Buffer(), base->Remaining());

-  Region new_region(update->Buffer(), update->Remaining());

-  Ensemble old_ensemble(old_region, "old");

-  Ensemble new_ensemble(new_region, "new");

-  std::vector<TransformationPatchGenerator*> generators;

-  Status generators_status = FindGenerators(&old_ensemble, &new_ensemble,

-                                            &generators);

-  if (generators_status != C_OK)

-    return generators_status;

-

-  SinkStreamSet patch_streams;

-

-  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);

-

-  uint32 number_of_transformations = generators.size();

-  tranformation_descriptions->WriteVarint32(number_of_transformations);

-

-  for (size_t i = 0;  i < number_of_transformations;  ++i) {

-    CourgettePatchFile::TransformationMethodId kind = generators[i]->Kind();

-    tranformation_descriptions->WriteVarint32(kind);

-  }

-

-  for (size_t i = 0;  i < number_of_transformations;  ++i) {

-    Status status =

-        generators[i]->WriteInitialParameters(tranformation_descriptions);

-    if (status != C_OK)

-      return status;

-  }

-

-  //

-  // Generate sub-patch for parameters.

-  //

-  SinkStreamSet predicted_parameters_sink;

-  SinkStreamSet corrected_parameters_sink;

-

-  for (size_t i = 0;  i < number_of_transformations;  ++i) {

-    SinkStreamSet single_predicted_parameters;

-    Status status;

-    status = generators[i]->PredictTransformParameters(

-        &single_predicted_parameters);

-    if (status != C_OK)

-      return status;

-    if (!predicted_parameters_sink.WriteSet(&single_predicted_parameters))

-      return C_STREAM_ERROR;

-

-    SinkStreamSet single_corrected_parameters;

-    status = generators[i]->CorrectedTransformParameters(

-        &single_corrected_parameters);

-    if (status != C_OK)

-      return status;

-    if (!corrected_parameters_sink.WriteSet(&single_corrected_parameters))

-      return C_STREAM_ERROR;

-  }

-

-  SinkStream linearized_predicted_parameters;

-  SinkStream linearized_corrected_parameters;

-

-  if (!predicted_parameters_sink.CopyTo(&linearized_predicted_parameters))

-    return C_STREAM_ERROR;

-  if (!corrected_parameters_sink.CopyTo(&linearized_corrected_parameters))

-    return C_STREAM_ERROR;

-

-  SourceStream predicted_parameters_source;

-  SourceStream corrected_parameters_source;

-  predicted_parameters_source.Init(linearized_predicted_parameters);

-  corrected_parameters_source.Init(linearized_corrected_parameters);

-

-  Status delta1_status = GenerateSimpleDelta(&predicted_parameters_source,

-                                             &corrected_parameters_source,

-                                             parameter_correction);

-  if (delta1_status != C_OK)

-    return delta1_status;

-

-  //

-  // Generate sub-patch for elements.

-  //

-  corrected_parameters_source.Init(linearized_corrected_parameters);

-  SourceStreamSet corrected_parameters_source_set;

-  if (!corrected_parameters_source_set.Init(&corrected_parameters_source))

-    return C_STREAM_ERROR;

-

-  SinkStreamSet predicted_transformed_elements;

-  SinkStreamSet corrected_transformed_elements;

-

-  for (size_t i = 0;  i < number_of_transformations;  ++i) {

-    SourceStreamSet single_parameters;

-    if (!corrected_parameters_source_set.ReadSet(&single_parameters))

-      return C_STREAM_ERROR;

-    SinkStreamSet single_predicted_transformed_element;

-    SinkStreamSet single_corrected_transformed_element;

-    Status status = generators[i]->Transform(

-        &single_parameters,

-        &single_predicted_transformed_element,

-        &single_corrected_transformed_element);

-    if (status != C_OK)

-      return status;

-    if (!single_parameters.Empty())

-      return C_STREAM_NOT_CONSUMED;

-    if (!predicted_transformed_elements.WriteSet(

-            &single_predicted_transformed_element))

-      return C_STREAM_ERROR;

-    if (!corrected_transformed_elements.WriteSet(

-            &single_corrected_transformed_element))

-      return C_STREAM_ERROR;

-  }

-

-  if (!corrected_parameters_source_set.Empty())

-    return C_STREAM_NOT_CONSUMED;

-

-  SinkStream linearized_predicted_transformed_elements;

-  SinkStream linearized_corrected_transformed_elements;

-

-  if (!predicted_transformed_elements.CopyTo(

-          &linearized_predicted_transformed_elements))

-    return C_STREAM_ERROR;

-  if (!corrected_transformed_elements.CopyTo(

-          &linearized_corrected_transformed_elements))

-    return C_STREAM_ERROR;

-

-  SourceStream predicted_transformed_elements_source;

-  SourceStream corrected_transformed_elements_source;

-  predicted_transformed_elements_source

-      .Init(linearized_predicted_transformed_elements);

-  corrected_transformed_elements_source

-      .Init(linearized_corrected_transformed_elements);

-

-  Status delta2_status =

-      GenerateSimpleDelta(&predicted_transformed_elements_source,

-                          &corrected_transformed_elements_source,

-                          transformed_elements_correction);

-  if (delta2_status != C_OK)

-    return delta2_status;

-

-  //

-  // Generate sub-patch for whole enchilada.

-  //

-  SinkStream predicted_ensemble;

-

-  predicted_ensemble.Write(base->Buffer(), base->Remaining());

-

-  SourceStreamSet corrected_transformed_elements_source_set;

-  corrected_transformed_elements_source

-      .Init(linearized_corrected_transformed_elements);

-  if (!corrected_transformed_elements_source_set

-      .Init(&corrected_transformed_elements_source))

-    return C_STREAM_ERROR;

-

-  for (size_t i = 0;  i < number_of_transformations;  ++i) {

-    SourceStreamSet single_corrected_transformed_element;

-    if (!corrected_transformed_elements_source_set.ReadSet(

-            &single_corrected_transformed_element))

-      return C_STREAM_ERROR;

-    Status status = generators[i]->Reform(&single_corrected_transformed_element,

-                                          &predicted_ensemble);

-    if (status != C_OK)

-      return status;

-    if (!single_corrected_transformed_element.Empty())

-      return C_STREAM_NOT_CONSUMED;

-  }

-

-  if (!corrected_transformed_elements_source_set.Empty())

-    return C_STREAM_NOT_CONSUMED;

-

-  FreeGenerators(&generators);

-

-  SourceStream predicted_ensemble_source;

-  predicted_ensemble_source.Init(predicted_ensemble);

-  Status delta3_status = GenerateSimpleDelta(&predicted_ensemble_source,

-                                             update,

-                                             ensemble_correction);

-  if (delta3_status != C_OK)

-    return delta3_status;

-

-  //

-  // Final output stream has a header followed by a StreamSet.

-  //

-  final_patch->WriteVarint32(CourgettePatchFile::kMagic);

-  final_patch->WriteVarint32(CourgettePatchFile::kVersion);

-

-  final_patch->WriteVarint32(

-      CalculateCrc(old_region.start(), old_region.length()));

-  final_patch->WriteVarint32(

-      CalculateCrc(new_region.start(), new_region.length()));

-

-  if (!patch_streams.CopyTo(final_patch))

-    return C_STREAM_ERROR;

-

-  return C_OK;

-}

-

-}  // namespace

+// Copyright (c) 2009 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.
+
+// This file contains the code to create the patch.
+
+
+#include "courgette/ensemble.h"
+
+#include <vector>
+#include <limits>
+
+#include "base/basictypes.h"
+#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/image_info.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"
+
+namespace courgette {
+
+TransformationPatchGenerator::TransformationPatchGenerator(
+    Element* old_element,
+    Element* new_element,
+    TransformationPatcher* patcher)
+    : old_element_(old_element),
+      new_element_(new_element),
+      patcher_(patcher) {
+}
+
+TransformationPatchGenerator::~TransformationPatchGenerator() {
+  delete patcher_;
+}
+
+// The default implementation of PredictTransformParameters delegates to the
+// patcher.
+Status TransformationPatchGenerator::PredictTransformParameters(
+    SinkStreamSet* prediction) {
+  return patcher_->PredictTransformParameters(prediction);
+}
+
+// The default implementation of Reform delegates to the patcher.
+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;
+  }
+}
+
+// FindGenerators finds TransformationPatchGenerators for the elements of
+// |new_ensemble|.  For each element of |new_ensemble| we find the closest
+// matching element from |old_ensemble| and use that as the basis for
+// differential compression.  The elements have to be the same kind so as to
+// support transformation into the same kind of 'new representation'.
+//
+Status FindGenerators(Ensemble* old_ensemble, Ensemble* new_ensemble,
+                      std::vector<TransformationPatchGenerator*>* generators) {
+  base::Time start_find_time = base::Time::Now();
+  old_ensemble->FindEmbeddedElements();
+  new_ensemble->FindEmbeddedElements();
+  LOG(INFO) << "done FindEmbeddedElements "
+            << (base::Time::Now() - start_find_time).InSecondsF();
+
+  std::vector<Element*> old_elements(old_ensemble->elements());
+  std::vector<Element*> new_elements(new_ensemble->elements());
+
+  LOG(INFO) << "old has " << old_elements.size() << " elements";
+  LOG(INFO) << "new has " << new_elements.size() << " elements";
+
+  DifferenceEstimator difference_estimator;
+  std::vector<DifferenceEstimator::Base*> bases;
+
+  base::Time start_bases_time = base::Time::Now();
+  for (size_t i = 0;  i < old_elements.size();  ++i) {
+    bases.push_back(
+        difference_estimator.MakeBase(old_elements[i]->region()));
+  }
+  LOG(INFO) << "done make bases "
+            << (base::Time::Now() - start_bases_time).InSecondsF()
+            << "s";
+
+  for (size_t new_index = 0;  new_index < new_elements.size();  ++new_index) {
+    Element* new_element = new_elements[new_index];
+    DifferenceEstimator::Subject* new_subject =
+        difference_estimator.MakeSubject(new_element->region());
+
+    // Search through old elements to find the best match.
+    //
+    // TODO(sra): This is O(N x M), i.e. O(N^2) since old_ensemble and
+    // new_ensemble probably have a very similar structure.  We can make the
+    // search faster by making the comparison provided by DifferenceEstimator
+    // more nuanced, returning early if the measured difference is greater than
+    // the current best.  This will be most effective if we can arrange that the
+    // first elements we try to match are likely the 'right' ones.  We could
+    // prioritize elements that are of a similar size or similar position in the
+    // sequence of elements.
+    //
+    Element* best_old_element = NULL;
+    size_t best_difference = std::numeric_limits<size_t>::max();
+    for (size_t old_index = 0;  old_index < old_elements.size();  ++old_index) {
+      Element* old_element = old_elements[old_index];
+      // Elements of different kinds are incompatible.
+      if (old_element->kind() != new_element->kind())
+        continue;
+
+      base::Time start_compare = base::Time::Now();
+      DifferenceEstimator::Base* old_base = bases[old_index];
+      size_t difference = difference_estimator.Measure(old_base, new_subject);
+
+      LOG(INFO) << "Compare " << old_element->Name()
+                << " to " << new_element->Name()
+                << " --> " << difference
+                << " in " << (base::Time::Now() - start_compare).InSecondsF()
+                << "s";
+      if (difference == 0) {
+        LOG(INFO) << "Skip " << new_element->Name()
+                  << " - identical to " << old_element->Name();
+        best_difference = 0;
+        best_old_element = NULL;
+        break;
+      }
+      if (difference < best_difference) {
+        best_difference = difference;
+        best_old_element = old_element;
+      }
+    }
+
+    if (best_old_element) {
+      LOG(INFO) << "Matched " << best_old_element->Name()
+                << " to " << new_element->Name()
+                << " --> " << best_difference;
+      TransformationPatchGenerator* generator =
+          MakeGenerator(best_old_element, new_element);
+      if (generator)
+        generators->push_back(generator);
+    }
+  }
+
+  LOG(INFO) << "done FindGenerators "
+            << "found " << generators->size() << " in "
+            << (base::Time::Now() - start_find_time).InSecondsF() << "s";
+
+  return C_OK;
+}
+
+void FreeGenerators(std::vector<TransformationPatchGenerator*>* generators) {
+  for (size_t i = 0;  i < generators->size();  ++i) {
+    delete (*generators)[i];
+  }
+  generators->clear();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+Status GenerateEnsemblePatch(SourceStream* base,
+                             SourceStream* update,
+                             SinkStream* final_patch) {
+  Region old_region(base->Buffer(), base->Remaining());
+  Region new_region(update->Buffer(), update->Remaining());
+  Ensemble old_ensemble(old_region, "old");
+  Ensemble new_ensemble(new_region, "new");
+  std::vector<TransformationPatchGenerator*> generators;
+  Status generators_status = FindGenerators(&old_ensemble, &new_ensemble,
+                                            &generators);
+  if (generators_status != C_OK)
+    return generators_status;
+
+  SinkStreamSet patch_streams;
+
+  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);
+
+  uint32 number_of_transformations = generators.size();
+  tranformation_descriptions->WriteVarint32(number_of_transformations);
+
+  for (size_t i = 0;  i < number_of_transformations;  ++i) {
+    CourgettePatchFile::TransformationMethodId kind = generators[i]->Kind();
+    tranformation_descriptions->WriteVarint32(kind);
+  }
+
+  for (size_t i = 0;  i < number_of_transformations;  ++i) {
+    Status status =
+        generators[i]->WriteInitialParameters(tranformation_descriptions);
+    if (status != C_OK)
+      return status;
+  }
+
+  //
+  // Generate sub-patch for parameters.
+  //
+  SinkStreamSet predicted_parameters_sink;
+  SinkStreamSet corrected_parameters_sink;
+
+  for (size_t i = 0;  i < number_of_transformations;  ++i) {
+    SinkStreamSet single_predicted_parameters;
+    Status status;
+    status = generators[i]->PredictTransformParameters(
+        &single_predicted_parameters);
+    if (status != C_OK)
+      return status;
+    if (!predicted_parameters_sink.WriteSet(&single_predicted_parameters))
+      return C_STREAM_ERROR;
+
+    SinkStreamSet single_corrected_parameters;
+    status = generators[i]->CorrectedTransformParameters(
+        &single_corrected_parameters);
+    if (status != C_OK)
+      return status;
+    if (!corrected_parameters_sink.WriteSet(&single_corrected_parameters))
+      return C_STREAM_ERROR;
+  }
+
+  SinkStream linearized_predicted_parameters;
+  SinkStream linearized_corrected_parameters;
+
+  if (!predicted_parameters_sink.CopyTo(&linearized_predicted_parameters))
+    return C_STREAM_ERROR;
+  if (!corrected_parameters_sink.CopyTo(&linearized_corrected_parameters))
+    return C_STREAM_ERROR;
+
+  SourceStream predicted_parameters_source;
+  SourceStream corrected_parameters_source;
+  predicted_parameters_source.Init(linearized_predicted_parameters);
+  corrected_parameters_source.Init(linearized_corrected_parameters);
+
+  Status delta1_status = GenerateSimpleDelta(&predicted_parameters_source,
+                                             &corrected_parameters_source,
+                                             parameter_correction);
+  if (delta1_status != C_OK)
+    return delta1_status;
+
+  //
+  // Generate sub-patch for elements.
+  //
+  corrected_parameters_source.Init(linearized_corrected_parameters);
+  SourceStreamSet corrected_parameters_source_set;
+  if (!corrected_parameters_source_set.Init(&corrected_parameters_source))
+    return C_STREAM_ERROR;
+
+  SinkStreamSet predicted_transformed_elements;
+  SinkStreamSet corrected_transformed_elements;
+
+  for (size_t i = 0;  i < number_of_transformations;  ++i) {
+    SourceStreamSet single_parameters;
+    if (!corrected_parameters_source_set.ReadSet(&single_parameters))
+      return C_STREAM_ERROR;
+    SinkStreamSet single_predicted_transformed_element;
+    SinkStreamSet single_corrected_transformed_element;
+    Status status = generators[i]->Transform(
+        &single_parameters,
+        &single_predicted_transformed_element,
+        &single_corrected_transformed_element);
+    if (status != C_OK)
+      return status;
+    if (!single_parameters.Empty())
+      return C_STREAM_NOT_CONSUMED;
+    if (!predicted_transformed_elements.WriteSet(
+            &single_predicted_transformed_element))
+      return C_STREAM_ERROR;
+    if (!corrected_transformed_elements.WriteSet(
+            &single_corrected_transformed_element))
+      return C_STREAM_ERROR;
+  }
+
+  if (!corrected_parameters_source_set.Empty())
+    return C_STREAM_NOT_CONSUMED;
+
+  SinkStream linearized_predicted_transformed_elements;
+  SinkStream linearized_corrected_transformed_elements;
+
+  if (!predicted_transformed_elements.CopyTo(
+          &linearized_predicted_transformed_elements))
+    return C_STREAM_ERROR;
+  if (!corrected_transformed_elements.CopyTo(
+          &linearized_corrected_transformed_elements))
+    return C_STREAM_ERROR;
+
+  SourceStream predicted_transformed_elements_source;
+  SourceStream corrected_transformed_elements_source;
+  predicted_transformed_elements_source
+      .Init(linearized_predicted_transformed_elements);
+  corrected_transformed_elements_source
+      .Init(linearized_corrected_transformed_elements);
+
+  Status delta2_status =
+      GenerateSimpleDelta(&predicted_transformed_elements_source,
+                          &corrected_transformed_elements_source,
+                          transformed_elements_correction);
+  if (delta2_status != C_OK)
+    return delta2_status;
+
+  //
+  // Generate sub-patch for whole enchilada.
+  //
+  SinkStream predicted_ensemble;
+
+  predicted_ensemble.Write(base->Buffer(), base->Remaining());
+
+  SourceStreamSet corrected_transformed_elements_source_set;
+  corrected_transformed_elements_source
+      .Init(linearized_corrected_transformed_elements);
+  if (!corrected_transformed_elements_source_set
+      .Init(&corrected_transformed_elements_source))
+    return C_STREAM_ERROR;
+
+  for (size_t i = 0;  i < number_of_transformations;  ++i) {
+    SourceStreamSet single_corrected_transformed_element;
+    if (!corrected_transformed_elements_source_set.ReadSet(
+            &single_corrected_transformed_element))
+      return C_STREAM_ERROR;
+    Status status = generators[i]->Reform(&single_corrected_transformed_element,
+                                          &predicted_ensemble);
+    if (status != C_OK)
+      return status;
+    if (!single_corrected_transformed_element.Empty())
+      return C_STREAM_NOT_CONSUMED;
+  }
+
+  if (!corrected_transformed_elements_source_set.Empty())
+    return C_STREAM_NOT_CONSUMED;
+
+  FreeGenerators(&generators);
+
+  SourceStream predicted_ensemble_source;
+  predicted_ensemble_source.Init(predicted_ensemble);
+  Status delta3_status = GenerateSimpleDelta(&predicted_ensemble_source,
+                                             update,
+                                             ensemble_correction);
+  if (delta3_status != C_OK)
+    return delta3_status;
+
+  //
+  // Final output stream has a header followed by a StreamSet.
+  //
+  final_patch->WriteVarint32(CourgettePatchFile::kMagic);
+  final_patch->WriteVarint32(CourgettePatchFile::kVersion);
+
+  final_patch->WriteVarint32(
+      CalculateCrc(old_region.start(), old_region.length()));
+  final_patch->WriteVarint32(
+      CalculateCrc(new_region.start(), new_region.length()));
+
+  if (!patch_streams.CopyTo(final_patch))
+    return C_STREAM_ERROR;
+
+  return C_OK;
+}
+
+}  // namespace
diff --git a/third_party/courgette/image_info.cc b/courgette/image_info.cc
index ca615dd..5651f36 100644
--- a/third_party/courgette/image_info.cc
+++ b/courgette/image_info.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/courgette/image_info.h"
+#include "courgette/image_info.h"
 
 #include <memory.h>
 #include <algorithm>
@@ -389,4 +389,3 @@ bool PEInfo::ParseRelocs(std::vector<RVA> *relocs) {
 }
 
 }  // namespace courgette
-
diff --git a/third_party/courgette/image_info.h b/courgette/image_info.h
index ffdbe97..53a0be7 100644
--- a/third_party/courgette/image_info.h
+++ b/courgette/image_info.h
@@ -197,4 +197,3 @@ class PEInfo {
 
 }  // namespace
 #endif  // COURGETTE_IMAGE_INFO_H_
-
diff --git a/third_party/courgette/image_info_unittest.cc b/courgette/image_info_unittest.cc
index 43ef65f..6d6deb5 100644
--- a/third_party/courgette/image_info_unittest.cc
+++ b/courgette/image_info_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/courgette/image_info.h"
+#include "courgette/image_info.h"
 
 #include <string>
 
@@ -20,7 +20,6 @@ class ImageInfoTest : public testing::Test {
  private:
   void SetUp() {
     PathService::Get(base::DIR_SOURCE_ROOT, &test_dir_);
-    // file_util::AppendToPath(&test_dir_, L"third_party");
     file_util::AppendToPath(&test_dir_, L"courgette");
     file_util::AppendToPath(&test_dir_, L"testdata");
   }
diff --git a/third_party/courgette/memory_monitor.cc b/courgette/memory_monitor.cc
index 2077f12..51cb0cc 100644
--- a/third_party/courgette/memory_monitor.cc
+++ b/courgette/memory_monitor.cc
@@ -1,122 +1,122 @@
-#include <stdio.h>

-#include <map>

-

-#include "base/logging.h"

-#include "base/string_util.h"

-

-bool inH = true;

-struct H {

-  H() { inH = false;  tick_ = 0; bw_ = 0; d_bw_ = d_tick_ = 0; m_bw_ = 0; mem_ = high_ = 0;}

-  ~H() {

-    inH = true;

-    int i = 0;

-    for (M::iterator p = m_.begin(); p != m_.end(); ++p, ++i) {

-      size_t s = p->first;

-      LOG(INFO) << StringPrintf("%3d %8u: %8u %8u %8u %8u", i, s,

-             m_[s], c_[s], h_[s], h_[s] * s);

-    }

-    LOG(INFO) << "Peak " << fmt(high_);

-  }

-

-  std::string fmt(size_t s) {

-    if (s > 1000000000) return StringPrintf("%.3gG", s/(1000000000.0));

-    if (s > 1000000) return StringPrintf("%.3gM", s/(1000000.));

-    if (s > 9999) return StringPrintf("%.3gk", s/(1000.));

-    return StringPrintf("%d", (int)s);

-  }

-

-  void tick(size_t w, char sign) {

-    d_tick_ += 1;

-    d_bw_ += w;

-    const size_t T = 4*4*1024;

-    const size_t M = 4*1024*1024;

-    bool print = false;

-    if (d_tick_ >= T) {

-      tick_ += (d_tick_/T)*T;

-      d_tick_ %= T;

-      print = true;

-    }

-    if (d_bw_ >= M) {

-      bw_ += (d_bw_/M) * M;

-      d_bw_ %= M;

-      print = true;

-    }

-    if (!print) return;

-    std::string o;

-    StringAppendF(&o, "%u:", tick_ + d_tick_);

-    StringAppendF(&o, " (%c%s)", sign, fmt(w).c_str());

-    size_t sum = 0;

-    for (M::iterator p = c_.begin(); p != c_.end(); ++p) {

-      size_t s = p->first;

-      size_t n = p->second;

-      if (n) {

-        if (s*n >= 64*1024)

-          if (n == 1)

-            StringAppendF(&o, "  %s", fmt(s).c_str());

-          else

-            StringAppendF(&o, "  %s*%u", fmt(s).c_str(), n);

-        sum += s*n;

-        }

-    }

-    StringAppendF(&o, "  = %s", fmt(sum).c_str());

-    LOG(INFO) << o;

-    //printf("%s\n", o.c_str());

-    if (sum > 200*1024*1024) {

-      // __asm int 3;

-      m_bw_ = sum;

-    }

-  }

-  void add(size_t s, void *p) {

-    if (!inH) {

-      inH = true;

-      mem_ += s; if (mem_ > high_) high_ = mem_;

-      c_[s] += 1;

-      m_[s] += 1;

-      if (c_[s] > h_[s]) h_[s] = c_[s];

-      allocs_[p] = s;

-      inH = false;

-      tick(s, '+');

-    }

-  }

-

-  void sub(void *p) {

-    if (!inH) {

-      inH = true;

-      size_t s = allocs_[p];

-      if (s) {

-        mem_ -= s;

-        c_[s] -= 1;

-        allocs_[p] = 0;

-        tick(s, '-');

-      }

-      inH = false;

-    }

-  }

-

-  typedef std::map<size_t, size_t> M;

-  M m_;

-  M c_;

-  M h_;

-

-  size_t bw_;

-  size_t d_bw_;

-  size_t tick_;

-  size_t d_tick_;

-  size_t m_bw_;

-  size_t mem_;

-  size_t high_;

-

-  std::map<void*, size_t> allocs_;

-} _H;

-

-void* operator new(size_t s) {

-  //printf("%u\n", s);

-  void *p = malloc(s);

-  _H.add(s, p);

-  return p;

-}

-

-void operator delete(void *p) {

-  _H.sub(p);

-  free(p);

-}

+#include <stdio.h>
+#include <map>
+
+#include "base/logging.h"
+#include "base/string_util.h"
+
+bool inH = true;
+struct H {
+  H() { inH = false;  tick_ = 0; bw_ = 0; d_bw_ = d_tick_ = 0; m_bw_ = 0; mem_ = high_ = 0;}
+  ~H() {
+    inH = true;
+    int i = 0;
+    for (M::iterator p = m_.begin(); p != m_.end(); ++p, ++i) {
+      size_t s = p->first;
+      LOG(INFO) << StringPrintf("%3d %8u: %8u %8u %8u %8u", i, s,
+             m_[s], c_[s], h_[s], h_[s] * s);
+    }
+    LOG(INFO) << "Peak " << fmt(high_);
+  }
+
+  std::string fmt(size_t s) {
+    if (s > 1000000000) return StringPrintf("%.3gG", s/(1000000000.0));
+    if (s > 1000000) return StringPrintf("%.3gM", s/(1000000.));
+    if (s > 9999) return StringPrintf("%.3gk", s/(1000.));
+    return StringPrintf("%d", (int)s);
+  }
+
+  void tick(size_t w, char sign) {
+    d_tick_ += 1;
+    d_bw_ += w;
+    const size_t T = 4*4*1024;
+    const size_t M = 4*1024*1024;
+    bool print = false;
+    if (d_tick_ >= T) {
+      tick_ += (d_tick_/T)*T;
+      d_tick_ %= T;
+      print = true;
+    }
+    if (d_bw_ >= M) {
+      bw_ += (d_bw_/M) * M;
+      d_bw_ %= M;
+      print = true;
+    }
+    if (!print) return;
+    std::string o;
+    StringAppendF(&o, "%u:", tick_ + d_tick_);
+    StringAppendF(&o, " (%c%s)", sign, fmt(w).c_str());
+    size_t sum = 0;
+    for (M::iterator p = c_.begin(); p != c_.end(); ++p) {
+      size_t s = p->first;
+      size_t n = p->second;
+      if (n) {
+        if (s*n >= 64*1024)
+          if (n == 1)
+            StringAppendF(&o, "  %s", fmt(s).c_str());
+          else
+            StringAppendF(&o, "  %s*%u", fmt(s).c_str(), n);
+        sum += s*n;
+        }
+    }
+    StringAppendF(&o, "  = %s", fmt(sum).c_str());
+    LOG(INFO) << o;
+    //printf("%s\n", o.c_str());
+    if (sum > 200*1024*1024) {
+      // __asm int 3;
+      m_bw_ = sum;
+    }
+  }
+  void add(size_t s, void *p) {
+    if (!inH) {
+      inH = true;
+      mem_ += s; if (mem_ > high_) high_ = mem_;
+      c_[s] += 1;
+      m_[s] += 1;
+      if (c_[s] > h_[s]) h_[s] = c_[s];
+      allocs_[p] = s;
+      inH = false;
+      tick(s, '+');
+    }
+  }
+
+  void sub(void *p) {
+    if (!inH) {
+      inH = true;
+      size_t s = allocs_[p];
+      if (s) {
+        mem_ -= s;
+        c_[s] -= 1;
+        allocs_[p] = 0;
+        tick(s, '-');
+      }
+      inH = false;
+    }
+  }
+
+  typedef std::map<size_t, size_t> M;
+  M m_;
+  M c_;
+  M h_;
+
+  size_t bw_;
+  size_t d_bw_;
+  size_t tick_;
+  size_t d_tick_;
+  size_t m_bw_;
+  size_t mem_;
+  size_t high_;
+
+  std::map<void*, size_t> allocs_;
+} _H;
+
+void* operator new(size_t s) {
+  //printf("%u\n", s);
+  void *p = malloc(s);
+  _H.add(s, p);
+  return p;
+}
+
+void operator delete(void *p) {
+  _H.sub(p);
+  free(p);
+}
diff --git a/third_party/courgette/region.h b/courgette/region.h
index 00a130f..4aafbca 100644
--- a/third_party/courgette/region.h
+++ b/courgette/region.h
@@ -1,62 +1,62 @@
-// Copyright (c) 2009 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.

-

-#ifndef COURGETTE_REGION_H_

-#define COURGETTE_REGION_H_

-

-#include <string>

-

-#include "base/basictypes.h"

-

-namespace courgette {

-

-// A Region is a descriptor for a region of memory.  It has a start address and

-// a length measured in bytes.  The Region object does not own the memory.

-//

-class Region {

- public:

-  // Default constructor: and empty region.

-  Region() : start_(NULL), length_(0) {}

-

-  // Usual constructor for regions given a |start| address and |length|.

-  Region(const void* start, size_t length)

-      : start_(static_cast<const uint8*>(start)),

-        length_(length) {

-  }

-

-  // String constructor.  Region is owned by the string, so the string should

-  // have a lifetime greater than the region.

-  explicit Region(const std::string& string)

-      : start_(reinterpret_cast<const uint8*>(string.c_str())),

-        length_(string.length()) {

-  }

-

-  // Copy constructor.

-  Region(const Region& other) : start_(other.start_), length_(other.length_) {}

-

-  // Assignment 'operator' makes |this| region the same as |other|.

-  Region& assign(const Region& other) {

-    this->start_ = other.start_;

-    this->length_ = other.length_;

-    return *this;

-  }

-

-  // Returns the starting address of the region.

-  const uint8* start() const { return start_; }

-

-  // Returns the length of the region.

-  size_t length() const { return length_; }

-

-  // Returns the address after the last byte of the region.

-  const uint8* end() const { return start_ + length_; }

-

- private:

-  const uint8* start_;

-  size_t length_;

-

-  void operator=(const Region&);  // Disallow assignment operator.

-};

-

-}  // namespace

-#endif  // COURGETTE_REGION_H_

+// Copyright (c) 2009 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.
+
+#ifndef COURGETTE_REGION_H_
+#define COURGETTE_REGION_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+
+namespace courgette {
+
+// A Region is a descriptor for a region of memory.  It has a start address and
+// a length measured in bytes.  The Region object does not own the memory.
+//
+class Region {
+ public:
+  // Default constructor: and empty region.
+  Region() : start_(NULL), length_(0) {}
+
+  // Usual constructor for regions given a |start| address and |length|.
+  Region(const void* start, size_t length)
+      : start_(static_cast<const uint8*>(start)),
+        length_(length) {
+  }
+
+  // String constructor.  Region is owned by the string, so the string should
+  // have a lifetime greater than the region.
+  explicit Region(const std::string& string)
+      : start_(reinterpret_cast<const uint8*>(string.c_str())),
+        length_(string.length()) {
+  }
+
+  // Copy constructor.
+  Region(const Region& other) : start_(other.start_), length_(other.length_) {}
+
+  // Assignment 'operator' makes |this| region the same as |other|.
+  Region& assign(const Region& other) {
+    this->start_ = other.start_;
+    this->length_ = other.length_;
+    return *this;
+  }
+
+  // Returns the starting address of the region.
+  const uint8* start() const { return start_; }
+
+  // Returns the length of the region.
+  size_t length() const { return length_; }
+
+  // Returns the address after the last byte of the region.
+  const uint8* end() const { return start_ + length_; }
+
+ private:
+  const uint8* start_;
+  size_t length_;
+
+  void operator=(const Region&);  // Disallow assignment operator.
+};
+
+}  // namespace
+#endif  // COURGETTE_REGION_H_
diff --git a/third_party/courgette/run_all_unittests.cc b/courgette/run_all_unittests.cc
index 5a17ba1..b5fc4a6 100644
--- a/third_party/courgette/run_all_unittests.cc
+++ b/courgette/run_all_unittests.cc
@@ -1,10 +1,9 @@
-// Copyright (c) 2009 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.

-

-#include "base/test_suite.h"

-

-int main(int argc, char** argv) {

-  return TestSuite(argc, argv).Run();

-}

-

+// Copyright (c) 2009 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.
+
+#include "base/test_suite.h"
+
+int main(int argc, char** argv) {
+  return TestSuite(argc, argv).Run();
+}
diff --git a/third_party/courgette/simple_delta.cc b/courgette/simple_delta.cc
index 8f93095..71038fd 100644
--- a/third_party/courgette/simple_delta.cc
+++ b/courgette/simple_delta.cc
@@ -1,41 +1,41 @@
-// Copyright (c) 2009 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.

-

-// Implementation of the byte-level differential compression used internally by

-// Courgette.

-

-#include "third_party/courgette/simple_delta.h"

-

-#include "base/basictypes.h"

-#include "base/logging.h"

-

-#include "third_party/courgette/bsdiff.h"

-

-namespace courgette {

-

-namespace {

-

-Status BSDiffStatusToStatus(BSDiffStatus status) {

-  switch (status) {

-    case OK: return C_OK;

-    case CRC_ERROR: return C_BINARY_DIFF_CRC_ERROR;

-    default: return C_GENERAL_ERROR;

-  }

-}

-

-}

-

-Status ApplySimpleDelta(SourceStream* old, SourceStream* delta,

-                        SinkStream* target) {

-  return BSDiffStatusToStatus(ApplyBinaryPatch(old, delta, target));

-}

-

-Status GenerateSimpleDelta(SourceStream* old, SourceStream* target,

-                           SinkStream* delta) {

-  LOG(INFO) << "GenerateSimpleDelta "

-            << old->Remaining() << " " << target->Remaining();

-  return BSDiffStatusToStatus(CreateBinaryPatch(old, target, delta));

-}

-

-}  // namespace courgette

+// Copyright (c) 2009 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.
+
+// Implementation of the byte-level differential compression used internally by
+// Courgette.
+
+#include "courgette/simple_delta.h"
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+
+#include "courgette/third_party/bsdiff.h"
+
+namespace courgette {
+
+namespace {
+
+Status BSDiffStatusToStatus(BSDiffStatus status) {
+  switch (status) {
+    case OK: return C_OK;
+    case CRC_ERROR: return C_BINARY_DIFF_CRC_ERROR;
+    default: return C_GENERAL_ERROR;
+  }
+}
+
+}
+
+Status ApplySimpleDelta(SourceStream* old, SourceStream* delta,
+                        SinkStream* target) {
+  return BSDiffStatusToStatus(ApplyBinaryPatch(old, delta, target));
+}
+
+Status GenerateSimpleDelta(SourceStream* old, SourceStream* target,
+                           SinkStream* delta) {
+  LOG(INFO) << "GenerateSimpleDelta "
+            << old->Remaining() << " " << target->Remaining();
+  return BSDiffStatusToStatus(CreateBinaryPatch(old, target, delta));
+}
+
+}  // namespace courgette
diff --git a/third_party/courgette/simple_delta.h b/courgette/simple_delta.h
index acb2227..d35333a 100644
--- a/third_party/courgette/simple_delta.h
+++ b/courgette/simple_delta.h
@@ -1,23 +1,23 @@
-// Copyright (c) 2009 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.

-

-// Byte level differential compression algorithm used by Courgette.

-

-#ifndef COURGETTE_SIMPLE_DELTA_H_

-#define COURGETTE_SIMPLE_DELTA_H_

-

-#include "third_party/courgette/courgette.h"

-#include "third_party/courgette/streams.h"

-

-namespace courgette {

-

-Status ApplySimpleDelta(SourceStream* old, SourceStream* delta,

-                        SinkStream* target);

-

-Status GenerateSimpleDelta(SourceStream* old, SourceStream* target,

-                           SinkStream* delta);

-

-}  // namespace courgette

-

-#endif  // COURGETTE_SIMPLE_DELTA_H_

+// Copyright (c) 2009 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.
+
+// Byte level differential compression algorithm used by Courgette.
+
+#ifndef COURGETTE_SIMPLE_DELTA_H_
+#define COURGETTE_SIMPLE_DELTA_H_
+
+#include "courgette/courgette.h"
+#include "courgette/streams.h"
+
+namespace courgette {
+
+Status ApplySimpleDelta(SourceStream* old, SourceStream* delta,
+                        SinkStream* target);
+
+Status GenerateSimpleDelta(SourceStream* old, SourceStream* target,
+                           SinkStream* delta);
+
+}  // namespace courgette
+
+#endif  // COURGETTE_SIMPLE_DELTA_H_
diff --git a/third_party/courgette/streams.cc b/courgette/streams.cc
index 9870cd2..365a416 100644
--- a/third_party/courgette/streams.cc
+++ b/courgette/streams.cc
@@ -16,7 +16,7 @@
 // we use it to cluster similar kinds of data which helps to generate longer
 // common subsequences and repeated sequences.
 
-#include "third_party/courgette/streams.h"
+#include "courgette/streams.h"
 
 #include <io.h>
 #include <memory.h>
@@ -31,7 +31,7 @@ static const unsigned int kStreamsSerializationFormatVersion = 20090218;
 
 //
 // This is a cut down Varint implementation, implementing only what we use for
-// streams.  The original implementation is at google3/util/coding/varint.h
+// streams.
 //
 class Varint {
  public:
diff --git a/third_party/courgette/streams.h b/courgette/streams.h
index 4985310..2fb824f 100644
--- a/third_party/courgette/streams.h
+++ b/courgette/streams.h
@@ -18,7 +18,7 @@
 
 #include "base/basictypes.h"
 
-#include "third_party/courgette/region.h"
+#include "courgette/region.h"
 
 namespace courgette {
 
diff --git a/third_party/courgette/streams_unittest.cc b/courgette/streams_unittest.cc
index 90a6061..dd330ce 100644
--- a/third_party/courgette/streams_unittest.cc
+++ b/courgette/streams_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/courgette/streams.h"
+#include "courgette/streams.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/third_party/courgette/testdata/en-US.dll b/courgette/testdata/en-US.dll
index f1ad46c..f1ad46c 100644
--- a/third_party/courgette/testdata/en-US.dll
+++ b/courgette/testdata/en-US.dll
diff --git a/third_party/courgette/testdata/setup1.exe b/courgette/testdata/setup1.exe
index da072f5..da072f5 100644
--- a/third_party/courgette/testdata/setup1.exe
+++ b/courgette/testdata/setup1.exe
diff --git a/third_party/courgette/testdata/setup2.exe b/courgette/testdata/setup2.exe
index 577a47f..577a47f 100644
--- a/third_party/courgette/testdata/setup2.exe
+++ b/courgette/testdata/setup2.exe
diff --git a/third_party/courgette/LICENCE.bsdiff b/courgette/third_party/LICENCE
index c146b5b..c146b5b 100644
--- a/third_party/courgette/LICENCE.bsdiff
+++ b/courgette/third_party/LICENCE
diff --git a/courgette/third_party/README.chromium b/courgette/third_party/README.chromium
new file mode 100644
index 0000000..d3037a1
--- /dev/null
+++ b/courgette/third_party/README.chromium
@@ -0,0 +1,23 @@
+This directory contains an extensively modified version of Colin Percival's

+bsdiff, available in its original form from:

+

+   http://www.daemonology.net/bsdiff/

+

+The basic principles of operation are best understood by reading Colin's

+unpublised paper:

+

+Colin Percival, Naive differences of executable code, http://www.daemonology.net/bsdiff/, 200

+

+The copy on this directory so extensively modified that the binary format is

+incompatible with the original and it cannot be compiled outside the Chromium

+source tree or the Courgette project.

+

+List of changes made to original code:

+  - wrapped functions in 'courgette' namespace

+  - renamed .c files to .cc

+  - added bsdiff.h header file

+  - changed the code to use streams.h from courgette

+  - changed the encoding of numbers to use the 'varint' encoding

+  - reformatted code to be closer to Google coding standards

+  - renamed variables

+  - added comments

diff --git a/third_party/courgette/bsdiff.h b/courgette/third_party/bsdiff.h
index bf7fdec..bf7fdec 100644
--- a/third_party/courgette/bsdiff.h
+++ b/courgette/third_party/bsdiff.h
diff --git a/third_party/courgette/bsdiff_apply.cc b/courgette/third_party/bsdiff_apply.cc
index f45ae14..4b6a011 100644
--- a/third_party/courgette/bsdiff_apply.cc
+++ b/courgette/third_party/bsdiff_apply.cc
@@ -32,10 +32,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/courgette/bsdiff.h"
+#include "courgette/third_party/bsdiff.h"
 
-#include "third_party/courgette/crc.h"
-#include "third_party/courgette/streams.h"
+#include "courgette/crc.h"
+#include "courgette/streams.h"
 
 namespace courgette {
 
diff --git a/third_party/courgette/bsdiff_create.cc b/courgette/third_party/bsdiff_create.cc
index cdd6cb6..d59dc21 100644
--- a/third_party/courgette/bsdiff_create.cc
+++ b/courgette/third_party/bsdiff_create.cc
@@ -19,7 +19,7 @@
                  --Stephen Adams <sra@chromium.org>
 */
 
-#include "third_party/courgette/bsdiff.h"
+#include "courgette/third_party/bsdiff.h"
 
 #include <stdlib.h>
 #include <algorithm>
@@ -29,8 +29,8 @@
 #include "base/string_util.h"
 #include "base/time.h"
 
-#include "third_party/courgette/crc.h"
-#include "third_party/courgette/streams.h"
+#include "courgette/crc.h"
+#include "courgette/streams.h"
 
 namespace courgette {
 
diff --git a/third_party/courgette/win32_x86_generator.h b/courgette/win32_x86_generator.h
index 8d3e683..3aabe9f 100644
--- a/third_party/courgette/win32_x86_generator.h
+++ b/courgette/win32_x86_generator.h
@@ -1,126 +1,126 @@
-// Copyright (c) 2009 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.

-

-// This is the transformation and adjustment for Windows X86 executables.

-

-#ifndef COURGETTE_WIN32_X86_GENERATOR_H_

-#define COURGETTE_WIN32_X86_GENERATOR_H_

-

-#include "base/scoped_ptr.h"

-

-#include "third_party/courgette/ensemble.h"

-

-namespace courgette {

-

-class CourgetteWin32X86PatchGenerator : public TransformationPatchGenerator {

- public:

-  CourgetteWin32X86PatchGenerator(Element* old_element,

-                                  Element* new_element,

-                                  CourgetteWin32X86Patcher* patcher)

-      : TransformationPatchGenerator(old_element, new_element, patcher) {

-  }

-

-  CourgettePatchFile::TransformationMethodId Kind() {

-    return CourgettePatchFile::T_COURGETTE_WIN32_X86;

-  }

-

-  Status WriteInitialParameters(SinkStream* parameter_stream) {

-    parameter_stream->WriteVarint32(old_element_->offset_in_ensemble());

-    parameter_stream->WriteVarint32(old_element_->region().length());

-    return C_OK;

-    // TODO(sra): Initialize |patcher_| with these parameters.

-  }

-

-  Status PredictTransformParameters(SinkStreamSet* prediction) {

-    return TransformationPatchGenerator::PredictTransformParameters(prediction);

-  }

-

-  Status CorrectedTransformParameters(SinkStreamSet* parameters) {

-    // No code needed to write an 'empty' parameter set.

-    return C_OK;

-  }

-

-  // The format of a transformed_element is a serialized EncodedProgram.  We

-  // first disassemble the original old and new Elements into AssemblyPrograms.

-  // Then we adjust the new AssemblyProgram to make it as much like the old one

-  // as possible, before converting the AssemblyPrograms to EncodedPrograms and

-  // serializing them.

-  Status Transform(SourceStreamSet* corrected_parameters,

-                   SinkStreamSet* old_transformed_element,

-                   SinkStreamSet* new_transformed_element) {

-    // Don't expect any corrected parameters.

-    if (!corrected_parameters->Empty())

-      return C_GENERAL_ERROR;

-

-    // Generate old version of program using |corrected_parameters|.

-    // TODO(sra): refactor to use same code from patcher_.

-    AssemblyProgram* old_program = NULL;

-    Status old_parse_status =

-        ParseWin32X86PE(old_element_->region().start(),

-                        old_element_->region().length(),

-                        &old_program);

-    if (old_parse_status != C_OK)

-      return old_parse_status;

-

-    AssemblyProgram* new_program = NULL;

-    Status new_parse_status =

-        ParseWin32X86PE(new_element_->region().start(),

-                        new_element_->region().length(),

-                        &new_program);

-    if (new_parse_status != C_OK) {

-      DeleteAssemblyProgram(old_program);

-      return new_parse_status;

-    }

-

-    EncodedProgram* old_encoded = NULL;

-    Status old_encode_status = Encode(old_program, &old_encoded);

-    if (old_encode_status != C_OK) {

-      DeleteAssemblyProgram(old_program);

-      return old_encode_status;

-    }

-

-    Status old_write_status =

-        WriteEncodedProgram(old_encoded, old_transformed_element);

-    DeleteEncodedProgram(old_encoded);

-    if (old_write_status != C_OK) {

-      DeleteAssemblyProgram(old_program);

-      return old_write_status;

-    }

-

-    Status adjust_status = Adjust(*old_program, new_program);

-    DeleteAssemblyProgram(old_program);

-    if (adjust_status != C_OK) {

-      DeleteAssemblyProgram(new_program);

-      return adjust_status;

-    }

-

-    EncodedProgram* new_encoded = NULL;

-    Status new_encode_status = Encode(new_program, &new_encoded);

-    DeleteAssemblyProgram(new_program);

-    if (new_encode_status != C_OK)

-      return new_encode_status;

-

-    Status new_write_status =

-        WriteEncodedProgram(new_encoded, new_transformed_element);

-    DeleteEncodedProgram(new_encoded);

-    if (new_write_status != C_OK)

-      return new_write_status;

-

-    return C_OK;

-  }

-

-  Status Reform(SourceStreamSet* transformed_element,

-                SinkStream* reformed_element) {

-    return TransformationPatchGenerator::Reform(transformed_element,

-                                                reformed_element);

-  }

-

- private:

-  ~CourgetteWin32X86PatchGenerator() { }

-

-  DISALLOW_COPY_AND_ASSIGN(CourgetteWin32X86PatchGenerator);

-};

-

-}  // namespace courgette

-#endif  // COURGETTE_WIN32_X86_GENERATOR_H_

+// Copyright (c) 2009 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.
+
+// This is the transformation and adjustment for Windows X86 executables.
+
+#ifndef COURGETTE_WIN32_X86_GENERATOR_H_
+#define COURGETTE_WIN32_X86_GENERATOR_H_
+
+#include "base/scoped_ptr.h"
+
+#include "courgette/ensemble.h"
+
+namespace courgette {
+
+class CourgetteWin32X86PatchGenerator : public TransformationPatchGenerator {
+ public:
+  CourgetteWin32X86PatchGenerator(Element* old_element,
+                                  Element* new_element,
+                                  CourgetteWin32X86Patcher* patcher)
+      : TransformationPatchGenerator(old_element, new_element, patcher) {
+  }
+
+  CourgettePatchFile::TransformationMethodId Kind() {
+    return CourgettePatchFile::T_COURGETTE_WIN32_X86;
+  }
+
+  Status WriteInitialParameters(SinkStream* parameter_stream) {
+    parameter_stream->WriteVarint32(old_element_->offset_in_ensemble());
+    parameter_stream->WriteVarint32(old_element_->region().length());
+    return C_OK;
+    // TODO(sra): Initialize |patcher_| with these parameters.
+  }
+
+  Status PredictTransformParameters(SinkStreamSet* prediction) {
+    return TransformationPatchGenerator::PredictTransformParameters(prediction);
+  }
+
+  Status CorrectedTransformParameters(SinkStreamSet* parameters) {
+    // No code needed to write an 'empty' parameter set.
+    return C_OK;
+  }
+
+  // The format of a transformed_element is a serialized EncodedProgram.  We
+  // first disassemble the original old and new Elements into AssemblyPrograms.
+  // Then we adjust the new AssemblyProgram to make it as much like the old one
+  // as possible, before converting the AssemblyPrograms to EncodedPrograms and
+  // serializing them.
+  Status Transform(SourceStreamSet* corrected_parameters,
+                   SinkStreamSet* old_transformed_element,
+                   SinkStreamSet* new_transformed_element) {
+    // Don't expect any corrected parameters.
+    if (!corrected_parameters->Empty())
+      return C_GENERAL_ERROR;
+
+    // Generate old version of program using |corrected_parameters|.
+    // TODO(sra): refactor to use same code from patcher_.
+    AssemblyProgram* old_program = NULL;
+    Status old_parse_status =
+        ParseWin32X86PE(old_element_->region().start(),
+                        old_element_->region().length(),
+                        &old_program);
+    if (old_parse_status != C_OK)
+      return old_parse_status;
+
+    AssemblyProgram* new_program = NULL;
+    Status new_parse_status =
+        ParseWin32X86PE(new_element_->region().start(),
+                        new_element_->region().length(),
+                        &new_program);
+    if (new_parse_status != C_OK) {
+      DeleteAssemblyProgram(old_program);
+      return new_parse_status;
+    }
+
+    EncodedProgram* old_encoded = NULL;
+    Status old_encode_status = Encode(old_program, &old_encoded);
+    if (old_encode_status != C_OK) {
+      DeleteAssemblyProgram(old_program);
+      return old_encode_status;
+    }
+
+    Status old_write_status =
+        WriteEncodedProgram(old_encoded, old_transformed_element);
+    DeleteEncodedProgram(old_encoded);
+    if (old_write_status != C_OK) {
+      DeleteAssemblyProgram(old_program);
+      return old_write_status;
+    }
+
+    Status adjust_status = Adjust(*old_program, new_program);
+    DeleteAssemblyProgram(old_program);
+    if (adjust_status != C_OK) {
+      DeleteAssemblyProgram(new_program);
+      return adjust_status;
+    }
+
+    EncodedProgram* new_encoded = NULL;
+    Status new_encode_status = Encode(new_program, &new_encoded);
+    DeleteAssemblyProgram(new_program);
+    if (new_encode_status != C_OK)
+      return new_encode_status;
+
+    Status new_write_status =
+        WriteEncodedProgram(new_encoded, new_transformed_element);
+    DeleteEncodedProgram(new_encoded);
+    if (new_write_status != C_OK)
+      return new_write_status;
+
+    return C_OK;
+  }
+
+  Status Reform(SourceStreamSet* transformed_element,
+                SinkStream* reformed_element) {
+    return TransformationPatchGenerator::Reform(transformed_element,
+                                                reformed_element);
+  }
+
+ private:
+  ~CourgetteWin32X86PatchGenerator() { }
+
+  DISALLOW_COPY_AND_ASSIGN(CourgetteWin32X86PatchGenerator);
+};
+
+}  // namespace courgette
+#endif  // COURGETTE_WIN32_X86_GENERATOR_H_
diff --git a/third_party/courgette/win32_x86_patcher.h b/courgette/win32_x86_patcher.h
index 4febad4..9ab53d9 100644
--- a/third_party/courgette/win32_x86_patcher.h
+++ b/courgette/win32_x86_patcher.h
@@ -1,95 +1,95 @@
-// Copyright (c) 2009 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.

-

-// This is the transformation for Windows X86 executables.

-

-#ifndef COURGETTE_WIN32_X86_PATCHER_H_

-#define COURGETTE_WIN32_X86_PATCHER_H_

-

-#include "third_party/courgette/ensemble.h"

-

-namespace courgette {

-

-// CourgetteWin32X86Patcher is a TransformationPatcher for Windows 32-bit

-// executables.

-//

-class CourgetteWin32X86Patcher : public TransformationPatcher {

- public:

-  explicit CourgetteWin32X86Patcher(const Region& region)

-      : ensemble_region_(region) {

-  }

-

-  Status Init(SourceStream* parameter_stream) {

-    if (!parameter_stream->ReadVarint32(&base_offset_))

-      return C_BAD_TRANSFORM;

-    if (!parameter_stream->ReadVarint32(&base_length_))

-      return C_BAD_TRANSFORM;

-

-    if (base_offset_ > ensemble_region_.length())

-      return C_BAD_TRANSFORM;

-    if (base_length_ > ensemble_region_.length() - base_offset_)

-      return C_BAD_TRANSFORM;

-

-    return C_OK;

-  }

-

-  Status PredictTransformParameters(SinkStreamSet* predicted_parameters) {

-    // No code needed to write an 'empty' predicted parameter set.

-    return C_OK;

-  }

-

-  Status Transform(SourceStreamSet* corrected_parameters,

-                   SinkStreamSet* transformed_element) {

-    Status status;

-    if (!corrected_parameters->Empty())

-      return C_GENERAL_ERROR;   // Don't expect any corrected parameters.

-

-    AssemblyProgram* program = NULL;

-    status = ParseWin32X86PE(ensemble_region_.start() + base_offset_,

-                             base_length_,

-                             &program);

-    if (status != C_OK)

-      return status;

-

-    EncodedProgram* encoded = NULL;

-    status = Encode(program, &encoded);

-    DeleteAssemblyProgram(program);

-    if (status != C_OK)

-      return status;

-

-    status = WriteEncodedProgram(encoded, transformed_element);

-    DeleteEncodedProgram(encoded);

-    if (status != C_OK)

-      return status;

-

-    return status;

-  }

-

-  Status Reform(SourceStreamSet* transformed_element,

-                SinkStream* reformed_element) {

-    Status status;

-    EncodedProgram* encoded_program = NULL;

-    status = ReadEncodedProgram(transformed_element, &encoded_program);

-    if (status != C_OK)

-      return status;

-

-    status = Assemble(encoded_program, reformed_element);

-    DeleteEncodedProgram(encoded_program);

-    if (status != C_OK)

-      return status;

-

-    return C_OK;

-  }

-

- private:

-  Region ensemble_region_;

-

-  uint32 base_offset_;

-  uint32 base_length_;

-

-  DISALLOW_COPY_AND_ASSIGN(CourgetteWin32X86Patcher);

-};

-

-}  // namespace

-#endif  // COURGETTE_WIN32_X86_PATCHER_H_

+// Copyright (c) 2009 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.
+
+// This is the transformation for Windows X86 executables.
+
+#ifndef COURGETTE_WIN32_X86_PATCHER_H_
+#define COURGETTE_WIN32_X86_PATCHER_H_
+
+#include "courgette/ensemble.h"
+
+namespace courgette {
+
+// CourgetteWin32X86Patcher is a TransformationPatcher for Windows 32-bit
+// executables.
+//
+class CourgetteWin32X86Patcher : public TransformationPatcher {
+ public:
+  explicit CourgetteWin32X86Patcher(const Region& region)
+      : ensemble_region_(region) {
+  }
+
+  Status Init(SourceStream* parameter_stream) {
+    if (!parameter_stream->ReadVarint32(&base_offset_))
+      return C_BAD_TRANSFORM;
+    if (!parameter_stream->ReadVarint32(&base_length_))
+      return C_BAD_TRANSFORM;
+
+    if (base_offset_ > ensemble_region_.length())
+      return C_BAD_TRANSFORM;
+    if (base_length_ > ensemble_region_.length() - base_offset_)
+      return C_BAD_TRANSFORM;
+
+    return C_OK;
+  }
+
+  Status PredictTransformParameters(SinkStreamSet* predicted_parameters) {
+    // No code needed to write an 'empty' predicted parameter set.
+    return C_OK;
+  }
+
+  Status Transform(SourceStreamSet* corrected_parameters,
+                   SinkStreamSet* transformed_element) {
+    Status status;
+    if (!corrected_parameters->Empty())
+      return C_GENERAL_ERROR;   // Don't expect any corrected parameters.
+
+    AssemblyProgram* program = NULL;
+    status = ParseWin32X86PE(ensemble_region_.start() + base_offset_,
+                             base_length_,
+                             &program);
+    if (status != C_OK)
+      return status;
+
+    EncodedProgram* encoded = NULL;
+    status = Encode(program, &encoded);
+    DeleteAssemblyProgram(program);
+    if (status != C_OK)
+      return status;
+
+    status = WriteEncodedProgram(encoded, transformed_element);
+    DeleteEncodedProgram(encoded);
+    if (status != C_OK)
+      return status;
+
+    return status;
+  }
+
+  Status Reform(SourceStreamSet* transformed_element,
+                SinkStream* reformed_element) {
+    Status status;
+    EncodedProgram* encoded_program = NULL;
+    status = ReadEncodedProgram(transformed_element, &encoded_program);
+    if (status != C_OK)
+      return status;
+
+    status = Assemble(encoded_program, reformed_element);
+    DeleteEncodedProgram(encoded_program);
+    if (status != C_OK)
+      return status;
+
+    return C_OK;
+  }
+
+ private:
+  Region ensemble_region_;
+
+  uint32 base_offset_;
+  uint32 base_length_;
+
+  DISALLOW_COPY_AND_ASSIGN(CourgetteWin32X86Patcher);
+};
+
+}  // namespace
+#endif  // COURGETTE_WIN32_X86_PATCHER_H_