Add product mode:

runtime/vm/dart_api_state.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
 #include "vm/bitfield.h"
 #include "vm/dart_api_impl.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/os_thread.h"
 #include "vm/visitor.h"
 #include "vm/weak_table.h"
 
 #include "vm/handles_impl.h"
 
 namespace dart {
 
-DECLARE_DEBUG_FLAG(bool, trace_zones);
-DECLARE_DEBUG_FLAG(bool, trace_handles);
-
 // Implementation of Zone support for very fast allocation of small chunks
 // of memory. The chunks cannot be deallocated individually, but instead
 // zones support deallocating all chunks in one fast operation when the
 // scope is exited.
 class ApiZone {
  public:
   // Create an empty zone.
   ApiZone() : zone_() {
     Thread* thread = Thread::Current();
     Zone* zone = thread != NULL ? thread->zone() : NULL;
     zone_.Link(zone);
     if (thread != NULL) {
       thread->set_zone(&zone_);
     }
-#ifdef DEBUG
     if (FLAG_trace_zones) {
       OS::PrintErr("*** Starting a new Api zone 0x%" Px "(0x%" Px ")\n",
                    reinterpret_cast<intptr_t>(this),
                    reinterpret_cast<intptr_t>(&zone_));
     }
-#endif
   }
 
   // Delete all memory associated with the zone.
   ~ApiZone() {
     Thread* thread = Thread::Current();
 #if defined(DEBUG)
     if (thread == NULL) {
       ASSERT(zone_.handles()->CountScopedHandles() == 0);
       ASSERT(zone_.handles()->CountZoneHandles() == 0);
     }
 #endif
     if ((thread != NULL) && (thread->zone() == &zone_)) {
       thread->set_zone(zone_.previous_);
     }
-#ifdef DEBUG
     if (FLAG_trace_zones) {
       OS::PrintErr("*** Deleting Api zone 0x%" Px "(0x%" Px ")\n",
                    reinterpret_cast<intptr_t>(this),
                    reinterpret_cast<intptr_t>(&zone_));
     }
-#endif
   }
 
   // Allocates an array sized to hold 'len' elements of type
   // 'ElementType'.  Checks for integer overflow when performing the
   // size computation.
   template <class ElementType>
   ElementType* Alloc(intptr_t len) { return zone_.Alloc<ElementType>(len); }
 
   // Allocates an array sized to hold 'len' elements of type
   // 'ElementType'.  The new array is initialized from the memory of
@@ skipping 271 matching lines @@
 static const int kLocalHandleSizeInWords = sizeof(LocalHandle) / kWordSize;
 static const int kLocalHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInLocalHandle = 0;
 class LocalHandles : Handles<kLocalHandleSizeInWords,
                              kLocalHandlesPerChunk,
                              kOffsetOfRawPtrInLocalHandle> {
  public:
   LocalHandles() : Handles<kLocalHandleSizeInWords,
                            kLocalHandlesPerChunk,
                            kOffsetOfRawPtrInLocalHandle>() {
-#ifdef DEBUG
     if (FLAG_trace_handles) {
       OS::PrintErr("*** Starting a new Local handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
-#endif
   }
   ~LocalHandles() {
-#ifdef DEBUG
     if (FLAG_trace_handles) {
       OS::PrintErr("***   Handle Counts for 0x(%" Px "):Scoped = %d\n",
                    reinterpret_cast<intptr_t>(this),
                    CountHandles());
       OS::PrintErr("*** Deleting Local handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
-#endif
   }
 
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kLocalHandleSizeInWords,
             kLocalHandlesPerChunk,
             kOffsetOfRawPtrInLocalHandle>::VisitObjectPointers(visitor);
   }
 
@@ skipping 32 matching lines @@
 static const int kPersistentHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInPersistentHandle = 0;
 class PersistentHandles : Handles<kPersistentHandleSizeInWords,
                                   kPersistentHandlesPerChunk,
                                   kOffsetOfRawPtrInPersistentHandle> {
  public:
   PersistentHandles() : Handles<kPersistentHandleSizeInWords,
                                 kPersistentHandlesPerChunk,
                                 kOffsetOfRawPtrInPersistentHandle>(),
         free_list_(NULL) {
-#ifdef DEBUG
     if (FLAG_trace_handles) {
       OS::PrintErr("*** Starting a new Persistent handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
-#endif
   }
   ~PersistentHandles() {
     free_list_ = NULL;
-#ifdef DEBUG
     if (FLAG_trace_handles) {
       OS::PrintErr("***   Handle Counts for 0x(%" Px "):Scoped = %d\n",
                    reinterpret_cast<intptr_t>(this),
                    CountHandles());
       OS::PrintErr("*** Deleting Persistent handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
-#endif
   }
 
   // Accessors.
   PersistentHandle* free_list() const { return free_list_; }
   void set_free_list(PersistentHandle* value) { free_list_ = value; }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kPersistentHandleSizeInWords,
             kPersistentHandlesPerChunk,
@@ skipping 310 matching lines @@
   ref->set_peer(peer);
   ref->set_callback(callback);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_