Identifying call sites that need to handle out of memory situations in Courgette.

courgette/ensemble_apply.cc

 // Copyright (c) 2010 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"
@@ skipping 202 matching lines @@
                             correction,
                             corrected_elements,
                             &corrected_elements_storage_);
 }
 
 Status EnsemblePatchApplication::TransformDown(
     SourceStreamSet* transformed_elements,
     SinkStream* basic_elements) {
   // Construct blob of original input followed by reformed elements.
 
-  basic_elements->Reserve(final_patch_input_size_prediction_);
+  if (final_patch_input_size_prediction_ &&

[robertshield, 2011/03/22 18:04:07]

Even though this looks right, this is a functional change and should be called
out in the CL description.

[tommi (sloooow) - chröme, 2011/03/22 18:37:49]

Removed the first check to maintain the previous functionality.

+      !basic_elements->Reserve(final_patch_input_size_prediction_)) {
+    return C_STREAM_ERROR;
+  }
 
   // The original input:
-  basic_elements->Write(base_region_.start(), base_region_.length());
+  if (!basic_elements->Write(base_region_.start(), base_region_.length()))
+    return C_STREAM_ERROR;
 
   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())
@@ skipping 166 matching lines @@
           static_cast<int>(new_sink_stream.Length()));
   if (written == -1)
     return C_WRITE_OPEN_ERROR;
   if (static_cast<size_t>(written) != new_sink_stream.Length())
     return C_WRITE_ERROR;
 
   return C_OK;
 }
 
 }  // namespace