Fold ApiObjectConverter use into ApiMessageReader

runtime/vm/dart_api_message.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_MESSAGE_H_
 #define VM_DART_API_MESSAGE_H_
 
 #include "include/dart_native_api.h"
 #include "platform/utils.h"
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
+#include "vm/message.h"
 #include "vm/raw_object.h"
 #include "vm/snapshot.h"
 
 namespace dart {
 
 // Use this C structure for reading internal objects in the serialized
 // data. These are objects that we need to process in order to
 // generate the Dart_CObject graph but that we don't want to expose in
 // that graph.
 struct Dart_CObject_Internal : public Dart_CObject {
@@ skipping 19 matching lines @@
 };
 
 
 // Reads a message snapshot into a C structure.
 class ApiMessageReader : public BaseReader {
  public:
   // The ApiMessageReader object must be enclosed by an ApiNativeScope.
   // Allocation of all C Heap objects is done in the zone associated with
   // the enclosing ApiNativeScope.
   ApiMessageReader(const uint8_t* buffer, intptr_t length);
+  explicit ApiMessageReader(Message* message);
   ~ApiMessageReader() { }
 
   Dart_CObject* ReadMessage();
 
  private:
   class BackRefNode {
    public:
     BackRefNode(Dart_CObject* reference, DeserializeState state)
         : reference_(reference), state_(state) {}
     Dart_CObject* reference() const { return reference_; }
@@ skipping 144 matching lines @@
 };
 
 
 // This class handles translation of certain RawObjects to CObjects for
 // NativeMessageHandlers.
 //
 // TODO(zra): Expand to support not only null, but also other VM heap objects
 // as well.
 class ApiObjectConverter : public AllStatic {
  public:
-  static bool CanConvert(RawObject* raw_obj) {
+  static bool CanConvert(const RawObject* raw_obj) {
     return !raw_obj->IsHeapObject() || (raw_obj == Object::null());
   }
 
-  static bool Convert(RawObject* raw_obj, Dart_CObject* c_obj) {
+  static bool Convert(const RawObject* raw_obj, Dart_CObject* c_obj) {
     if (!raw_obj->IsHeapObject()) {
-      ConvertSmi(reinterpret_cast<RawSmi*>(raw_obj), c_obj);
+      ConvertSmi(reinterpret_cast<const RawSmi*>(raw_obj), c_obj);
     } else if (raw_obj == Object::null()) {
       ConvertNull(c_obj);
     } else {
       return false;
     }
     return true;
   }
 
  private:
-  static void ConvertSmi(RawSmi* raw_smi, Dart_CObject* c_obj) {
+  static void ConvertSmi(const RawSmi* raw_smi, Dart_CObject* c_obj) {
     ASSERT(!raw_smi->IsHeapObject());
     intptr_t value = Smi::Value(raw_smi);
     if (Utils::IsInt(31, value)) {
       c_obj->type = Dart_CObject_kInt32;
       c_obj->value.as_int32 = static_cast<int32_t>(value);
     } else {
       c_obj->type = Dart_CObject_kInt64;
       c_obj->value.as_int64 = static_cast<int64_t>(value);
     }
   }
 
   static void ConvertNull(Dart_CObject* c_obj) {
     c_obj->type = Dart_CObject_kNull;
     c_obj->value.as_int64 = 0;
   }
 };
 
 }  // namespace dart
 
 #endif  // VM_DART_API_MESSAGE_H_