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

courgette/third_party/bsdiff_create.cc

 /*
   bsdiff.c -- Binary patch generator.
 
   Copyright 2003 Colin Percival
 
   For the terms under which this work may be distributed, please see
   the adjoining file "LICENSE".
 
   ChangeLog:
   2005-05-05 - Use the modified header struct from bspatch.h; use 32-bit
@@ skipping 173 matching lines @@
   if(memcmp(old+I[x],newbuf,std::min(oldsize-I[x],newsize))<0) {
     return search(I,old,oldsize,newbuf,newsize,x,en,pos);
   } else {
     return search(I,old,oldsize,newbuf,newsize,st,x,pos);
   }
 }
 
 //  End of 'verbatim' code.
 // ------------------------------------------------------------------------
 
-static void WriteHeader(SinkStream* stream, MBSPatchHeader* header) {
-  stream->Write(header->tag, sizeof(header->tag));
-  stream->WriteVarint32(header->slen);
-  stream->WriteVarint32(header->scrc32);
-  stream->WriteVarint32(header->dlen);
+static CheckBool WriteHeader(SinkStream* stream, MBSPatchHeader* header) {
+  bool ok = stream->Write(header->tag, sizeof(header->tag));
+  ok &= stream->WriteVarint32(header->slen);
+  ok &= stream->WriteVarint32(header->scrc32);
+  ok &= stream->WriteVarint32(header->dlen);
+  return ok;
 }
 
 BSDiffStatus CreateBinaryPatch(SourceStream* old_stream,
                                SourceStream* new_stream,
                                SinkStream* patch_stream)
 {
   base::Time start_bsdiff_time = base::Time::Now();
   VLOG(1) << "Start bsdiff";
   size_t initial_patch_stream_length = patch_stream->Length();
 
@@ skipping 159 matching lines @@
         }
 
         lenf += lens - overlap;
         lenb -= lens;
       };
 
       for (int i = 0;  i < lenf;  i++) {
         uint8 diff_byte = newbuf[lastscan + i] - old[lastpos + i];
         if (diff_byte) {
           ++diff_bytes_nonzero;
-          diff_skips->WriteVarint32(pending_diff_zeros);
+          if (!diff_skips->WriteVarint32(pending_diff_zeros))
+            return MEM_ERROR;
           pending_diff_zeros = 0;
-          diff_bytes->Write(&diff_byte, 1);
+          if (!diff_bytes->Write(&diff_byte, 1))
+            return MEM_ERROR;
         } else {
           ++pending_diff_zeros;
         }
       }
       int gap = (scan - lenb) - (lastscan + lenf);
-      for (int i = 0;  i < gap;  i++)
-        extra_bytes->Write(&newbuf[lastscan + lenf + i], 1);
+      for (int i = 0;  i < gap;  i++) {
+        if (!extra_bytes->Write(&newbuf[lastscan + lenf + i], 1))
+          return MEM_ERROR;
+      }
 
       diff_bytes_length += lenf;
       extra_bytes_length += gap;
 
       uint32 copy_count = lenf;
       uint32 extra_count = gap;
       int32 seek_adjustment = ((pos - lenb) - (lastpos + lenf));
 
-      control_stream_copy_counts->WriteVarint32(copy_count);
-      control_stream_extra_counts->WriteVarint32(extra_count);
-      control_stream_seeks->WriteVarint32Signed(seek_adjustment);
+      if (!control_stream_copy_counts->WriteVarint32(copy_count) ||
+          !control_stream_extra_counts->WriteVarint32(extra_count) ||
+          !control_stream_seeks->WriteVarint32Signed(seek_adjustment)) {
+        return MEM_ERROR;
+      }
+
       ++control_length;
 #ifdef DEBUG_bsmedberg
       VLOG(1) << StringPrintf("Writing a block:  copy: %-8u extra: %-8u seek: "
                               "%+-9d", copy_count, extra_count,
                               seek_adjustment);
 #endif
 
       lastscan = scan - lenb;   // Include the backward extension in seed.
       lastpos = pos - lenb;     //  ditto.
       lastoffset = lastpos - lastscan;
     }
   }
 
-  diff_skips->WriteVarint32(pending_diff_zeros);
+  if (!diff_skips->WriteVarint32(pending_diff_zeros))
+    return MEM_ERROR;
 
   I.clear();
 
   MBSPatchHeader header;
   // The string will have a null terminator that we don't use, hence '-1'.
   COMPILE_ASSERT(sizeof(MBS_PATCH_HEADER_TAG) - 1 == sizeof(header.tag),
                  MBS_PATCH_HEADER_TAG_must_match_header_field_size);
   memcpy(header.tag, MBS_PATCH_HEADER_TAG, sizeof(header.tag));
   header.slen     = oldsize;
   header.scrc32   = CalculateCrc(old, oldsize);
   header.dlen     = newsize;
 
-  WriteHeader(patch_stream, &header);
+  if (!WriteHeader(patch_stream, &header))
+    return MEM_ERROR;
 
   size_t diff_skips_length = diff_skips->Length();
-  patch_streams.CopyTo(patch_stream);
+  if (!patch_streams.CopyTo(patch_stream))
+    return MEM_ERROR;
 
   VLOG(1) << "Control tuples: " << control_length
           << "  copy bytes: " << diff_bytes_length
           << "  mistakes: " << diff_bytes_nonzero
           << "  (skips: " << diff_skips_length << ")"
           << "  extra bytes: " << extra_bytes_length
           << "\nUncompressed bsdiff patch size "
           << patch_stream->Length() - initial_patch_stream_length
           << "\nEnd bsdiff "
           << (base::Time::Now() - start_bsdiff_time).InSecondsF();
 
   return OK;
 }
 
 }  // namespace