More changes to use #ifndef PRODUCT ... #endif explicitly instead of relying on compiler magic.

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
@@ skipping 189 matching lines @@
 
 
 class IsolateMessageHandler : public MessageHandler {
  public:
   explicit IsolateMessageHandler(Isolate* isolate);
   ~IsolateMessageHandler();
 
   const char* name() const;
   void MessageNotify(Message::Priority priority);
   MessageStatus HandleMessage(Message* message);
+#ifndef PRODUCT
   void NotifyPauseOnStart();
   void NotifyPauseOnExit();
+#endif  // !PRODUCT
 
 #if defined(DEBUG)
   // Check that it is safe to access this handler.
   void CheckAccess();
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
 
  private:
   // A result of false indicates that the isolate should terminate the
@@ skipping 346 matching lines @@
   } else {
     const Object& result = Object::Handle(zone,
         DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
       status = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
   delete message;
+#ifndef PRODUCT
   if (status == kOK) {
     const Object& result =
         Object::Handle(zone, I->InvokePendingServiceExtensionCalls());
     if (result.IsError()) {
       status = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
+#endif  // !PRODUCT
   return status;
 }
 
 
+#ifndef PRODUCT
 void IsolateMessageHandler::NotifyPauseOnStart() {
   if (!FLAG_support_service) {
     return;
   }
   if (Service::debug_stream.enabled() || FLAG_warn_on_pause_with_no_debugger) {
     StartIsolateScope start_isolate(I);
     StackZone zone(T);
     HandleScope handle_scope(T);
     ServiceEvent pause_event(I, ServiceEvent::kPauseStart);
     Service::HandleEvent(&pause_event);
@@ skipping 12 matching lines @@
     StartIsolateScope start_isolate(I);
     StackZone zone(T);
     HandleScope handle_scope(T);
     ServiceEvent pause_event(I, ServiceEvent::kPauseExit);
     Service::HandleEvent(&pause_event);
   } else if (FLAG_trace_service) {
     OS::Print("vm-service: Dropping event of type PauseExit (%s)\n",
               I->name());
   }
 }
+#endif  // !PRODUCT
 
 
 #if defined(DEBUG)
 void IsolateMessageHandler::CheckAccess() {
   ASSERT(IsCurrentIsolate());
 }
 #endif
 
 
 bool IsolateMessageHandler::IsCurrentIsolate() const {
@@ skipping 320 matching lines @@
     result->debugger_ = new Debugger();
     result->debugger_->Initialize(result);
   }
   if (FLAG_trace_isolates) {
     if (name_prefix == NULL || strcmp(name_prefix, "vm-isolate") != 0) {
       OS::Print("[+] Starting isolate:\n"
                 "\tisolate:    %s\n", result->name());
     }
   }
 
+#ifndef PRODUCT
   if (FLAG_support_service) {
     ObjectIdRing::Init(result);
   }
+#endif  // !PRODUCT
 
   // Add to isolate list. Shutdown and delete the isolate on failure.
   if (!AddIsolateToList(result)) {
     result->LowLevelShutdown();
     Thread::ExitIsolate();
     delete result;
     return NULL;
   }
 
   return result;
@@ skipping 100 matching lines @@
   reload_context_ = NULL;
 }
 
 
 void Isolate::ReloadSources(bool test_mode) {
   ASSERT(!IsReloading());
   has_attempted_reload_ = true;
   reload_context_ = new IsolateReloadContext(this, test_mode);
   reload_context_->StartReload();
 }
-
-#endif
+#endif  // !PRODUCT
 
 
 void Isolate::DoneFinalizing() {
   NOT_IN_PRODUCT(
     if (IsReloading()) {
       reload_context_->FinishReload();
       if (reload_context_->has_error() && reload_context_->test_mode()) {
         // If the reload has an error and we are in test mode keep the reload
         // context on the isolate so that it can be used by unit tests.
         return;
@@ skipping 38 matching lines @@
 #ifndef PRODUCT
   if (FLAG_support_timeline) {
     TimelineStream* stream = Timeline::GetIsolateStream();
     ASSERT(stream != NULL);
     TimelineEvent* event = stream->StartEvent();
     if (event != NULL) {
       event->Instant("Runnable");
       event->Complete();
     }
   }
-#endif  // !PRODUCT
   if (FLAG_support_service && Service::isolate_stream.enabled()) {
     ServiceEvent runnableEvent(this, ServiceEvent::kIsolateRunnable);
     Service::HandleEvent(&runnableEvent);
   }
+#endif  // !PRODUCT
   return true;
 }
 
 
 bool Isolate::VerifyPauseCapability(const Object& capability) const {
   return !capability.IsNull() &&
       capability.IsCapability() &&
       (pause_capability() == Capability::Cast(capability).Id());
 }
 
@@ skipping 934 matching lines @@
   }
   const GrowableObjectArray& array =
       GrowableObjectArray::Handle(boxed_field_list_);
   if (array.Length() == 0) {
     return Field::null();
   }
   return Field::RawCast(array.RemoveLast());
 }
 
 
+#ifndef PRODUCT
 RawObject* Isolate::InvokePendingServiceExtensionCalls() {
   if (!FLAG_support_service) {
     return Object::null();
   }
   GrowableObjectArray& calls =
       GrowableObjectArray::Handle(GetAndClearPendingServiceExtensionCalls());
   if (calls.IsNull()) {
     return Object::null();
   }
   // Grab run function.
@@ skipping 160 matching lines @@
   String& handler_name = String::Handle();
   for (intptr_t i = 0; i < handlers.Length(); i += kRegisteredEntrySize) {
     handler_name ^= handlers.At(i + kRegisteredNameIndex);
     ASSERT(!handler_name.IsNull());
     if (handler_name.Equals(name)) {
       return Instance::RawCast(handlers.At(i + kRegisteredHandlerIndex));
     }
   }
   return Instance::null();
 }
+#endif  // !PRODUCT
 
 
 void Isolate::WakePauseEventHandler(Dart_Isolate isolate) {
   Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   MonitorLocker ml(iso->pause_loop_monitor_);
   ml.Notify();
 }
 
 
 void Isolate::PauseEventHandler() {
@@ skipping 557 matching lines @@
 void IsolateSpawnState::DecrementSpawnCount() {
   ASSERT(spawn_count_monitor_ != NULL);
   ASSERT(spawn_count_ != NULL);
   MonitorLocker ml(spawn_count_monitor_);
   ASSERT(*spawn_count_ > 0);
   *spawn_count_ = *spawn_count_ - 1;
   ml.Notify();
 }
 
 }  // namespace dart