VM: Make more globals constant where easily possible.

runtime/vm/service.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/service.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/globals.h"
 
@@ skipping 79 matching lines @@
   ASSERT(zone != NULL);
   const intptr_t id = ring_->GetIdForObject(obj.raw(), policy_);
   return zone->PrintToString("objects/%" Pd "", id);
 }
 
 
 // TODO(johnmccutchan): Unify embedder service handler lists and their APIs.
 EmbedderServiceHandler* Service::isolate_service_handler_head_ = NULL;
 EmbedderServiceHandler* Service::root_service_handler_head_ = NULL;
 struct ServiceMethodDescriptor;
-ServiceMethodDescriptor* FindMethod(const char* method_name);
+const ServiceMethodDescriptor* FindMethod(const char* method_name);
 
 
 // Support for streams defined in embedders.
 Dart_ServiceStreamListenCallback Service::stream_listen_callback_ = NULL;
 Dart_ServiceStreamCancelCallback Service::stream_cancel_callback_ = NULL;
 Dart_GetVMServiceAssetsArchive Service::get_service_assets_callback_ = NULL;
 
 // These are the set of streams known to the core VM.
 StreamInfo Service::vm_stream("VM");
 StreamInfo Service::isolate_stream("Isolate");
@@ skipping 373 matching lines @@
     return (value != NULL);
   }
 };
 
 
 #define ISOLATE_PARAMETER new IdParameter("isolateId", true)
 
 
 class EnumParameter : public MethodParameter {
  public:
-  EnumParameter(const char* name, bool required, const char** enums)
+  EnumParameter(const char* name, bool required, const char* const* enums)
       : MethodParameter(name, required),
         enums_(enums) {
   }
 
   virtual bool Validate(const char* value) const {
     if (value == NULL) {
       return true;
     }
     for (intptr_t i = 0; enums_[i] != NULL; i++) {
       if (strcmp(value, enums_[i]) == 0) {
         return true;
       }
     }
     return false;
   }
 
  private:
-  const char** enums_;
+  const char* const* enums_;
 };
 
 
 // If the key is not found, this function returns the last element in the
 // values array. This can be used to encode the default value.
 template<typename T>
-T EnumMapper(const char* value, const char** enums, T* values) {
+T EnumMapper(const char* value, const char* const* enums, T* values) {
   ASSERT(value != NULL);
   intptr_t i = 0;
   for (i = 0; enums[i] != NULL; i++) {
     if (strcmp(value, enums[i]) == 0) {
       return values[i];
     }
   }
   // Default value.
   return values[i];
 }
@@ skipping 107 matching lines @@
         // TODO(johnmccutchan): Support creating, deleting, and selecting
         // custom service id zones.
         // For now, always return an error.
         PrintInvalidParamError(&js, "_idZone");
         js.PostReply();
         return;
       }
     }
     const char* c_method_name = method_name.ToCString();
 
-    ServiceMethodDescriptor* method = FindMethod(c_method_name);
+    const ServiceMethodDescriptor* method = FindMethod(c_method_name);
     if (method != NULL) {
       if (!ValidateParameters(method->parameters, &js)) {
         js.PostReply();
         return;
       }
       if (method->entry(T, &js)) {
         js.PostReply();
       } else {
         // NOTE(turnidge): All message handlers currently return true,
         // so this case shouldn't be reached, at present.
@@ skipping 720 matching lines @@
   return table.At(id);
 }
 
 
 static RawObject* LookupHeapObjectCode(Isolate* isolate,
                                        char** parts, int num_parts) {
   if (num_parts != 2) {
     return Object::sentinel().raw();
   }
   uword pc;
-  static const char* kCollectedPrefix = "collected-";
+  static const char* const kCollectedPrefix = "collected-";
   static intptr_t kCollectedPrefixLen = strlen(kCollectedPrefix);
-  static const char* kNativePrefix = "native-";
-  static intptr_t kNativePrefixLen = strlen(kNativePrefix);
-  static const char* kReusedPrefix = "reused-";
-  static intptr_t kReusedPrefixLen = strlen(kReusedPrefix);
+  static const char* const kNativePrefix = "native-";
+  static const intptr_t kNativePrefixLen = strlen(kNativePrefix);
+  static const char* const kReusedPrefix = "reused-";
+  static const intptr_t kReusedPrefixLen = strlen(kReusedPrefix);
   const char* id = parts[1];
   if (strncmp(kCollectedPrefix, id, kCollectedPrefixLen) == 0) {
     if (!GetUnsignedIntegerId(&id[kCollectedPrefixLen], &pc, 16)) {
       return Object::sentinel().raw();
     }
     // TODO(turnidge): Return "collected" instead.
     return Object::null();
   }
   if (strncmp(kNativePrefix, id, kNativePrefixLen) == 0) {
     if (!GetUnsignedIntegerId(&id[kNativePrefixLen], &pc, 16)) {
@@ skipping 1035 matching lines @@
 };
 
 
 static bool GetIsolateMetric(Thread* thread, JSONStream* js) {
   const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
     PrintMissingParamError(js, "metricId");
     return true;
   }
   // Verify id begins with "metrics/".
-  static const char* kMetricIdPrefix = "metrics/";
+  static const char* const kMetricIdPrefix = "metrics/";
   static intptr_t kMetricIdPrefixLen = strlen(kMetricIdPrefix);
   if (strncmp(metric_id, kMetricIdPrefix, kMetricIdPrefixLen) != 0) {
     PrintInvalidParamError(js, "metricId");
     return true;
   }
   // Check if id begins with "metrics/native/".
-  static const char* kNativeMetricIdPrefix = "metrics/native/";
+  static const char* const kNativeMetricIdPrefix = "metrics/native/";
   static intptr_t kNativeMetricIdPrefixLen = strlen(kNativeMetricIdPrefix);
   const bool native_metric =
       strncmp(metric_id, kNativeMetricIdPrefix, kNativeMetricIdPrefixLen) == 0;
   if (native_metric) {
     const char* id = metric_id + kNativeMetricIdPrefixLen;
     return HandleNativeMetric(thread, js, id);
   }
   const char* id = metric_id + kMetricIdPrefixLen;
   return HandleDartMetric(thread, js, id);
 }
@@ skipping 188 matching lines @@
 
 
 static bool GetTagProfile(Thread* thread, JSONStream* js) {
   JSONObject miniProfile(js);
   miniProfile.AddProperty("type", "TagProfile");
   thread->isolate()->vm_tag_counters()->PrintToJSONObject(&miniProfile);
   return true;
 }
 
 
-static const char* tags_enum_names[] = {
+static const char* const tags_enum_names[] = {
   "None",
   "UserVM",
   "UserOnly",
   "VMUser",
   "VMOnly",
   NULL,
 };
 
 
-static Profile::TagOrder tags_enum_values[] = {
+static const Profile::TagOrder tags_enum_values[] = {
   Profile::kNoTags,
   Profile::kUserVM,
   Profile::kUser,
   Profile::kVMUser,
   Profile::kVM,
   Profile::kNoTags,  // Default value.
 };
 
 
 static const MethodParameter* get_cpu_profile_params[] = {
@@ skipping 704 matching lines @@
     return true;
   }
   const Class& cls = Class::Handle(GetClassForId(isolate, cid));
   ASSERT(!cls.IsNull());
   cls.SetTraceAllocation(enable);
   PrintSuccess(js);
   return true;
 }
 
 
-static ServiceMethodDescriptor service_methods_[] = {
+static const ServiceMethodDescriptor service_methods_[] = {
   { "_dumpIdZone", DumpIdZone, NULL },
   { "_echo", Echo,
     NULL },
   { "_respondWithMalformedJson", RespondWithMalformedJson,
     NULL },
   { "_respondWithMalformedObject", RespondWithMalformedObject,
     NULL },
   { "_triggerEchoEvent", TriggerEchoEvent,
     NULL },
   { "addBreakpoint", AddBreakpoint,
@@ skipping 86 matching lines @@
     set_name_params },
   { "_setTraceClassAllocation", SetTraceClassAllocation,
     set_trace_class_allocation_params },
   { "setVMName", SetVMName,
     set_vm_name_params },
   { "_setVMTimelineFlag", SetVMTimelineFlag,
     set_vm_timeline_flag_params },
 };
 
 
-ServiceMethodDescriptor* FindMethod(const char* method_name) {
+const ServiceMethodDescriptor* FindMethod(const char* method_name) {
   intptr_t num_methods = sizeof(service_methods_) /
                          sizeof(service_methods_[0]);
   for (intptr_t i = 0; i < num_methods; i++) {
-    ServiceMethodDescriptor& method = service_methods_[i];
+    const ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart