Add support for abortion in v8::OutputStream.

src/profile-generator.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2122 matching lines @@
   return diff;
 }
 
 
 class OutputStreamWriter {
  public:
   explicit OutputStreamWriter(v8::OutputStream* stream)
       : stream_(stream),
         chunk_size_(stream->GetChunkSize()),
         chunk_(chunk_size_),
-        chunk_pos_(0) {
+        chunk_pos_(0),
+        aborted_(false) {
     ASSERT(chunk_size_ > 0);
   }
+  bool aborted() { return aborted_; }
   void AddCharacter(char c) {
     ASSERT(c != '\0');
     ASSERT(chunk_pos_ < chunk_size_);
     chunk_[chunk_pos_++] = c;
     MaybeWriteChunk();
   }
   void AddString(const char* s) {
     AddSubstring(s, StrLength(s));
   }
   void AddSubstring(const char* s, int n) {
     if (n <= 0) return;
     ASSERT(static_cast<size_t>(n) <= strlen(s));
     const char* s_end = s + n;
     while (s < s_end) {
       int s_chunk_size = Min(
           chunk_size_ - chunk_pos_, static_cast<int>(s_end - s));
       ASSERT(s_chunk_size > 0);
       memcpy(chunk_.start() + chunk_pos_, s, s_chunk_size);
       s += s_chunk_size;
       chunk_pos_ += s_chunk_size;
       MaybeWriteChunk();
     }
   }
   void AddNumber(int n) { AddNumberImpl<int>(n, "%d"); }
   void AddNumber(unsigned n) { AddNumberImpl<unsigned>(n, "%u"); }
   void AddNumber(uint64_t n) { AddNumberImpl<uint64_t>(n, "%llu"); }
   void Finalize() {
+    if (aborted_) return;
     ASSERT(chunk_pos_ < chunk_size_);
     if (chunk_pos_ != 0) {
       WriteChunk();
     }
     stream_->EndOfStream();
   }
 
  private:
   template<typename T>
   void AddNumberImpl(T n, const char* format) {
     ScopedVector<char> buffer(32);
     int result = OS::SNPrintF(buffer, format, n);
     USE(result);
     ASSERT(result != -1);
     AddString(buffer.start());
   }
   void MaybeWriteChunk() {
     ASSERT(chunk_pos_ <= chunk_size_);
     if (chunk_pos_ == chunk_size_) {
       WriteChunk();
       chunk_pos_ = 0;
     }
   }
   void WriteChunk() {
-    stream_->WriteAsciiChunk(chunk_.start(), chunk_pos_);
+    if (aborted_) return;
+    if (stream_->WriteAsciiChunk(chunk_.start(), chunk_pos_) ==
+        v8::OutputStream::kAbort) aborted_ = true;
   }
 
   v8::OutputStream* stream_;
   int chunk_size_;
   ScopedVector<char> chunk_;
   int chunk_pos_;
+  bool aborted_;
 };
 
 void HeapSnapshotJSONSerializer::Serialize(v8::OutputStream* stream) {
   ASSERT(writer_ == NULL);
   writer_ = new OutputStreamWriter(stream);
 
   // Since nodes graph is cyclic, we need the first pass to enumerate
   // them. Strings can be serialized in one pass.
   EnumerateNodes();
-
-  writer_->AddCharacter('{');
-  writer_->AddString("\"snapshot\":{");
-  SerializeSnapshot();
-  writer_->AddString("},\n");
-  writer_->AddString("\"nodes\":[");
-  SerializeNodes();
-  writer_->AddString("],\n");
-  writer_->AddString("\"strings\":[");
-  SerializeStrings();
-  writer_->AddCharacter(']');
-  writer_->AddCharacter('}');
-  writer_->Finalize();
-
+  SerializeImpl();
+  
   delete writer_;
   writer_ = NULL;
 }
 
 
+void HeapSnapshotJSONSerializer::SerializeImpl() {
+  writer_->AddCharacter('{');
+  writer_->AddString("\"snapshot\":{");
+  SerializeSnapshot();
+  if (writer_->aborted()) return;
+  writer_->AddString("},\n");
+  writer_->AddString("\"nodes\":[");
+  SerializeNodes();
+  if (writer_->aborted()) return;
+  writer_->AddString("],\n");
+  writer_->AddString("\"strings\":[");
+  SerializeStrings();
+  if (writer_->aborted()) return;
+  writer_->AddCharacter(']');
+  writer_->AddCharacter('}');
+  writer_->Finalize();
+}
+
+
 class HeapSnapshotJSONSerializerEnumerator {
  public:
   explicit HeapSnapshotJSONSerializerEnumerator(HeapSnapshotJSONSerializer* s)
       : s_(s) {
   }
   void Apply(HeapEntry** entry) {
     s_->GetNodeId(*entry);
   }
  private:
   HeapSnapshotJSONSerializer* s_;
@@ skipping 47 matching lines @@
   writer_->AddNumber(GetStringId(entry->name()));
   writer_->AddCharacter(',');
   writer_->AddNumber(entry->id());
   writer_->AddCharacter(',');
   writer_->AddNumber(entry->self_size());
   Vector<HeapGraphEdge> children = entry->children();
   writer_->AddCharacter(',');
   writer_->AddNumber(children.length());
   for (int i = 0; i < children.length(); ++i) {
     SerializeEdge(&children[i]);
+    if (writer_->aborted()) return;
   }
 }
 
 
 void HeapSnapshotJSONSerializer::SerializeNodes() {
   // The first (zero) item of nodes array is a JSON-ified object
   // describing node serialization layout.
   // We use a set of macros to improve readability.
 #define JSON_A(s) "["s"]"
 #define JSON_O(s) "{"s"}"
@@ skipping 47 matching lines @@
     for (int i = 1; i < sorted_nodes.length(); ++i) {
       HeapEntry* prev_heap_entry =
           reinterpret_cast<HeapEntry*>(sorted_nodes[i-1]->key);
       prev_value += node_fields_count +
           prev_heap_entry->children().length() * edge_fields_count;
       sorted_nodes[i]->value = reinterpret_cast<void*>(prev_value);
     }
   }
   for (int i = 0; i < sorted_nodes.length(); ++i) {
     SerializeNode(reinterpret_cast<HeapEntry*>(sorted_nodes[i]->key));
+    if (writer_->aborted()) return;
   }
 }
 
 
 void HeapSnapshotJSONSerializer::SerializeSnapshot() {
   writer_->AddString("\"title\":\"");
   writer_->AddString(snapshot_->title());
   writer_->AddString("\"");
   writer_->AddString(",\"uid\":");
   writer_->AddNumber(snapshot_->uid());
@@ skipping 60 matching lines @@
 
 
 void HeapSnapshotJSONSerializer::SerializeStrings() {
   List<HashMap::Entry*> sorted_strings;
   SortHashMap(&strings_, &sorted_strings);
   writer_->AddString("\"<dummy>\"");
   for (int i = 0; i < sorted_strings.length(); ++i) {
     writer_->AddCharacter(',');
     SerializeString(
         reinterpret_cast<const unsigned char*>(sorted_strings[i]->key));
+    if (writer_->aborted()) return;
   }
 }
 
 
 template<typename T>
 inline static int SortUsingEntryValue(const T* x, const T* y) {
   return reinterpret_cast<intptr_t>((*x)->value) -
       reinterpret_cast<intptr_t>((*y)->value);
 }
 
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING