[debug] Untangle DebugInfo from break point support

src/objects/debug-objects.cc

 // Copyright 2017 the V8 project 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 "src/objects/debug-objects.h"
 #include "src/objects/debug-objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
+bool DebugInfo::IsEmpty() const { return flags() == kNone; }
+
+bool DebugInfo::HasBreakInfo() const { return (flags() & kHasBreakInfo) != 0; }
+
+bool DebugInfo::ClearBreakInfo() {
+  Isolate* isolate = GetIsolate();
+
+  set_debug_bytecode_array(isolate->heap()->undefined_value());
+  set_break_points(isolate->heap()->empty_fixed_array());
+
+  int new_flags = flags() & ~kHasBreakInfo;
+  set_flags(new_flags);
+
+  return new_flags == kNone;
+}
+
 // Check if there is a break point at this source position.
 bool DebugInfo::HasBreakPoint(int source_position) {
+  DCHECK(HasBreakInfo());
   // Get the break point info object for this code offset.
   Object* break_point_info = GetBreakPointInfo(source_position);
 
   // If there is no break point info object or no break points in the break
   // point info object there is no break point at this code offset.
   if (break_point_info->IsUndefined(GetIsolate())) return false;
   return BreakPointInfo::cast(break_point_info)->GetBreakPointCount() > 0;
 }
 
 // Get the break point info object for this source position.
 Object* DebugInfo::GetBreakPointInfo(int source_position) {
+  DCHECK(HasBreakInfo());
   Isolate* isolate = GetIsolate();
   if (!break_points()->IsUndefined(isolate)) {
     for (int i = 0; i < break_points()->length(); i++) {
       if (!break_points()->get(i)->IsUndefined(isolate)) {
         BreakPointInfo* break_point_info =
             BreakPointInfo::cast(break_points()->get(i));
         if (break_point_info->source_position() == source_position) {
           return break_point_info;
         }
       }
     }
   }
   return isolate->heap()->undefined_value();
 }
 
 bool DebugInfo::ClearBreakPoint(Handle<DebugInfo> debug_info,
                                 Handle<Object> break_point_object) {
+  DCHECK(debug_info->HasBreakInfo());
   Isolate* isolate = debug_info->GetIsolate();
   if (debug_info->break_points()->IsUndefined(isolate)) return false;
 
   for (int i = 0; i < debug_info->break_points()->length(); i++) {
     if (debug_info->break_points()->get(i)->IsUndefined(isolate)) continue;
     Handle<BreakPointInfo> break_point_info = Handle<BreakPointInfo>(
         BreakPointInfo::cast(debug_info->break_points()->get(i)), isolate);
     if (BreakPointInfo::HasBreakPointObject(break_point_info,
                                             break_point_object)) {
       BreakPointInfo::ClearBreakPoint(break_point_info, break_point_object);
       return true;
     }
   }
   return false;
 }
 
 void DebugInfo::SetBreakPoint(Handle<DebugInfo> debug_info, int source_position,
                               Handle<Object> break_point_object) {
+  DCHECK(debug_info->HasBreakInfo());
   Isolate* isolate = debug_info->GetIsolate();
   Handle<Object> break_point_info(
       debug_info->GetBreakPointInfo(source_position), isolate);
   if (!break_point_info->IsUndefined(isolate)) {
     BreakPointInfo::SetBreakPoint(
         Handle<BreakPointInfo>::cast(break_point_info), break_point_object);
     return;
   }
 
   // Adding a new break point for a code offset which did not have any
@@ skipping 24 matching lines @@
 
   // Allocate new BreakPointInfo object and set the break point.
   Handle<BreakPointInfo> new_break_point_info =
       isolate->factory()->NewBreakPointInfo(source_position);
   BreakPointInfo::SetBreakPoint(new_break_point_info, break_point_object);
   debug_info->break_points()->set(index, *new_break_point_info);
 }
 
 // Get the break point objects for a source position.
 Handle<Object> DebugInfo::GetBreakPointObjects(int source_position) {
+  DCHECK(HasBreakInfo());
   Object* break_point_info = GetBreakPointInfo(source_position);
   Isolate* isolate = GetIsolate();
   if (break_point_info->IsUndefined(isolate)) {
     return isolate->factory()->undefined_value();
   }
   return Handle<Object>(
       BreakPointInfo::cast(break_point_info)->break_point_objects(), isolate);
 }
 
 // Get the total number of break points.
 int DebugInfo::GetBreakPointCount() {
+  DCHECK(HasBreakInfo());
   Isolate* isolate = GetIsolate();
   if (break_points()->IsUndefined(isolate)) return 0;
   int count = 0;
   for (int i = 0; i < break_points()->length(); i++) {
     if (!break_points()->get(i)->IsUndefined(isolate)) {
       BreakPointInfo* break_point_info =
           BreakPointInfo::cast(break_points()->get(i));
       count += break_point_info->GetBreakPointCount();
     }
   }
   return count;
 }
 
 Handle<Object> DebugInfo::FindBreakPointInfo(
     Handle<DebugInfo> debug_info, Handle<Object> break_point_object) {
+  DCHECK(debug_info->HasBreakInfo());
   Isolate* isolate = debug_info->GetIsolate();
   if (!debug_info->break_points()->IsUndefined(isolate)) {
     for (int i = 0; i < debug_info->break_points()->length(); i++) {
       if (!debug_info->break_points()->get(i)->IsUndefined(isolate)) {
         Handle<BreakPointInfo> break_point_info = Handle<BreakPointInfo>(
             BreakPointInfo::cast(debug_info->break_points()->get(i)), isolate);
         if (BreakPointInfo::HasBreakPointObject(break_point_info,
                                                 break_point_object)) {
           return break_point_info;
         }
@@ skipping 98 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined(GetIsolate())) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 }  // namespace internal
 }  // namespace v8