Remove some pause-related fields in a PRODUCT build

runtime/vm/message_handler.cc

 // Copyright (c) 2011, 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/message_handler.h"
 
 #include "vm/dart.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 38 matching lines @@
       return "Illegal";
   }
 }
 
 MessageHandler::MessageHandler()
     : queue_(new MessageQueue()),
       oob_queue_(new MessageQueue()),
       oob_message_handling_allowed_(true),
       live_ports_(0),
       paused_(0),
+#if !defined(PRODUCT)
       should_pause_on_start_(false),
       should_pause_on_exit_(false),
       is_paused_on_start_(false),
       is_paused_on_exit_(false),
+      paused_timestamp_(-1),
+#endif
       delete_me_(false),
-      paused_timestamp_(-1),
       pool_(NULL),
       task_(NULL),
       start_callback_(NULL),
       end_callback_(NULL),
       callback_data_(0) {
   ASSERT(queue_ != NULL);
   ASSERT(oob_queue_ != NULL);
 }
 
 MessageHandler::~MessageHandler() {
@@ skipping 199 matching lines @@
     return kOK;
   }
   MonitorLocker ml(&monitor_);
   ASSERT(!delete_me_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   return HandleMessages(&ml, false, false);
 }
 
+#if !defined(PRODUCT)
 bool MessageHandler::ShouldPauseOnStart(MessageStatus status) const {
   Isolate* owning_isolate = isolate();
   if (owning_isolate == NULL) {
     return false;
   }
   // If we are restarting or shutting down, we do not want to honor
   // should_pause_on_start or should_pause_on_exit.
   return (status != MessageHandler::kRestart &&
           status != MessageHandler::kShutdown) &&
          should_pause_on_start() && owning_isolate->is_runnable();
 }
 
 bool MessageHandler::ShouldPauseOnExit(MessageStatus status) const {
   Isolate* owning_isolate = isolate();
   if (owning_isolate == NULL) {
     return false;
   }
   return (status != MessageHandler::kRestart &&
           status != MessageHandler::kShutdown) &&
          should_pause_on_exit() && owning_isolate->is_runnable();
 }
+#endif
 
 bool MessageHandler::HasOOBMessages() {
   MonitorLocker ml(&monitor_);
   return !oob_queue_->IsEmpty();
 }
 
 void MessageHandler::TaskCallback() {
   ASSERT(Isolate::Current() == NULL);
   MessageStatus status = kOK;
   bool run_end_callback = false;
   bool delete_me = false;
   EndCallback end_callback = NULL;
   CallbackData callback_data = 0;
   {
     // We will occasionally release and reacquire this monitor in this
     // function. Whenever we reacquire the monitor we *must* process
     // all pending OOB messages, or we may miss a request for vm
     // shutdown.
     MonitorLocker ml(&monitor_);
+#if !defined(PRODUCT)
     if (ShouldPauseOnStart(kOK)) {
       if (!is_paused_on_start()) {
         PausedOnStartLocked(&ml, true);
       }
       // More messages may have come in before we (re)acquired the monitor.
       status = HandleMessages(&ml, false, false);
       if (ShouldPauseOnStart(status)) {
         // Still paused.
         ASSERT(oob_queue_->IsEmpty());
         task_ = NULL;  // No task in queue.
         return;
       } else {
         PausedOnStartLocked(&ml, false);
       }
     }
+#endif
 
     if (status == kOK) {
       if (start_callback_) {
         // Initialize the message handler by running its start function,
         // if we have one.  For an isolate, this will run the isolate's
         // main() function.
         //
         // Release the monitor_ temporarily while we call the start callback.
         ml.Exit();
         status = start_callback_(callback_data_);
         ASSERT(Isolate::Current() == NULL);
         start_callback_ = NULL;
         ml.Enter();
       }
 
       // Handle any pending messages for this message handler.
       if (status != kShutdown) {
         status = HandleMessages(&ml, (status == kOK), true);
       }
     }
 
     // The isolate exits when it encounters an error or when it no
     // longer has live ports.
     if (status != kOK || !HasLivePorts()) {
+#if !defined(PRODUCT)
       if (ShouldPauseOnExit(status)) {
         if (!is_paused_on_exit()) {
           if (FLAG_trace_service_pause_events) {
             OS::PrintErr(
                 "Isolate %s paused before exiting. "
                 "Use the Observatory to release it.\n",
                 name());
           }
           PausedOnExitLocked(&ml, true);
           // More messages may have come in while we released the monitor.
           status = HandleMessages(&ml, false, false);
         }
         if (ShouldPauseOnExit(status)) {
           // Still paused.
           ASSERT(oob_queue_->IsEmpty());
           task_ = NULL;  // No task in queue.
           return;
         } else {
           PausedOnExitLocked(&ml, false);
         }
       }
+#endif  // !defined(PRODUCT)
       if (FLAG_trace_isolates) {
         if (status != kOK && thread() != NULL) {
           const Error& error = Error::Handle(thread()->sticky_error());
           OS::Print(
               "[-] Stopping message handler (%s):\n"
               "\thandler:    %s\n"
               "\terror:    %s\n",
               MessageStatusString(status), name(), error.ToCString());
         } else {
           OS::Print(
@@ skipping 81 matching lines @@
 }
 
 void MessageHandler::decrement_live_ports() {
   MonitorLocker ml(&monitor_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   live_ports_--;
 }
 
+#if !defined(PRODUCT)
+void MessageHandler::DebugDump() {
+  PortMap::DebugDumpForMessageHandler(this);
+}
+
 void MessageHandler::PausedOnStart(bool paused) {
   MonitorLocker ml(&monitor_);
   PausedOnStartLocked(&ml, paused);
 }
 
-void MessageHandler::DebugDump() {
-  PortMap::DebugDumpForMessageHandler(this);
-}
-
 void MessageHandler::PausedOnStartLocked(MonitorLocker* ml, bool paused) {
   if (paused) {
     ASSERT(!is_paused_on_start_);
     is_paused_on_start_ = true;
     paused_timestamp_ = OS::GetCurrentTimeMillis();
   } else {
     ASSERT(is_paused_on_start_);
     is_paused_on_start_ = false;
     paused_timestamp_ = -1;
   }
@@ skipping 38 matching lines @@
     NotifyPauseOnExit();
     ml->Enter();
   } else {
     // Resumed. Clear the resume request of the owning isolate.
     Isolate* owning_isolate = isolate();
     if (owning_isolate != NULL) {
       owning_isolate->GetAndClearResumeRequest();
     }
   }
 }
+#endif  // !defined(PRODUCT)
 
 MessageHandler::AcquiredQueues::AcquiredQueues(MessageHandler* handler)
     : handler_(handler), ml_(&handler->monitor_) {
   ASSERT(handler != NULL);
   handler_->oob_message_handling_allowed_ = false;
 }
 
 MessageHandler::AcquiredQueues::~AcquiredQueues() {
   ASSERT(handler_ != NULL);
   handler_->oob_message_handling_allowed_ = true;
 }
 
 }  // namespace dart