Sandbox the component updater's patcher utility process.

courgette/courgette.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef COURGETTE_COURGETTE_H_
 #define COURGETTE_COURGETTE_H_
 
 #include <stddef.h>   // Required to define size_t on GCC
 
 #include "base/files/file_path.h"
 
+namespace base {
+class File;

[huangs, 2016/12/06 18:23:22]

Same comment as in bsdiff.h: Please
- Remove the forward declaration.
- #include "base/files/file.h"

[waffles, 2016/12/06 19:18:45]

Done, thanks; this was leftover from an intermediate form of the code.

+}  // namespace base
+
 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.
 
@@ skipping 54 matching lines @@
 
 // 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 base::FilePath::CharType* old_file_name,
                           const base::FilePath::CharType* patch_file_name,
                           const base::FilePath::CharType* new_file_name);
 
+// Applies the patch in |patch_file| to the bytes in |old_file| and writes the

[huangs, 2016/12/06 18:30:32]

Please move this between the SourceStream* version and the FielPath::CharType*
version, same in .cc file.

[waffles, 2016/12/06 19:18:45]

Done. Curious: What's the rationale here?

[huangs, 2016/12/06 19:40:07]

Ah, symmetry: We have A() calling B() alling C(), I'd prefer call direction to
be upwards.

+// transformed ensemble to |new_file|.
+// 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(base::File old_file,
+                          base::File patch_file,
+                          base::File new_file);
+
 // 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);
 
 // 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);
 
 // Adjusts |program| to look more like |model|.
 //
 Status Adjust(const AssemblyProgram& model, AssemblyProgram *program);
 
 }  // namespace courgette
 
 #endif  // COURGETTE_COURGETTE_H_