Rename SmartPointer to SmartArrayPointer.

src/debug-agent.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 151 matching lines @@
 }
 
 
 void DebuggerAgentSession::Run() {
   // Send the hello message.
   bool ok = DebuggerAgentUtil::SendConnectMessage(client_, *agent_->name_);
   if (!ok) return;
 
   while (true) {
     // Read data from the debugger front end.
-    SmartPointer<char> message = DebuggerAgentUtil::ReceiveMessage(client_);
+    SmartArrayPointer<char> message =
+        DebuggerAgentUtil::ReceiveMessage(client_);
 
     const char* msg = *message;
     bool is_closing_session = (msg == NULL);
 
     if (msg == NULL) {
       // If we lost the connection, then simulate a disconnect msg:
       msg = "{\"seq\":1,\"type\":\"request\",\"command\":\"disconnect\"}";
 
     } else {
       // Check if we're getting a disconnect request:
@@ skipping 42 matching lines @@
   // Shutdown the socket to end the blocking receive.
   client_->Shutdown();
 }
 
 
 const char* const DebuggerAgentUtil::kContentLength = "Content-Length";
 const int DebuggerAgentUtil::kContentLengthSize =
     StrLength(kContentLength);
 
 
-SmartPointer<char> DebuggerAgentUtil::ReceiveMessage(const Socket* conn) {
+SmartArrayPointer<char> DebuggerAgentUtil::ReceiveMessage(const Socket* conn) {
   int received;
 
   // Read header.
   int content_length = 0;
   while (true) {
     const int kHeaderBufferSize = 80;
     char header_buffer[kHeaderBufferSize];
     int header_buffer_position = 0;
     char c = '\0';  // One character receive buffer.
     char prev_c = '\0';  // Previous character.
 
     // Read until CRLF.
     while (!(c == '\n' && prev_c == '\r')) {
       prev_c = c;
       received = conn->Receive(&c, 1);
       if (received <= 0) {
         PrintF("Error %d\n", Socket::LastError());
-        return SmartPointer<char>();
+        return SmartArrayPointer<char>();
       }
 
       // Add character to header buffer.
       if (header_buffer_position < kHeaderBufferSize) {
         header_buffer[header_buffer_position++] = c;
       }
     }
 
     // Check for end of header (empty header line).
     if (header_buffer_position == 2) {  // Receive buffer contains CRLF.
@@ skipping 16 matching lines @@
           value++;
         }
         break;
       }
     }
 
     // Check that key is Content-Length.
     if (strcmp(key, kContentLength) == 0) {
       // Get the content length value if present and within a sensible range.
       if (value == NULL || strlen(value) > 7) {
-        return SmartPointer<char>();
+        return SmartArrayPointer<char>();
       }
       for (int i = 0; value[i] != '\0'; i++) {
         // Bail out if illegal data.
         if (value[i] < '0' || value[i] > '9') {
-          return SmartPointer<char>();
+          return SmartArrayPointer<char>();
         }
         content_length = 10 * content_length + (value[i] - '0');
       }
     } else {
       // For now just print all other headers than Content-Length.
       PrintF("%s: %s\n", key, value != NULL ? value : "(no value)");
     }
   }
 
   // Return now if no body.
   if (content_length == 0) {
-    return SmartPointer<char>();
+    return SmartArrayPointer<char>();
   }
 
   // Read body.
   char* buffer = NewArray<char>(content_length + 1);
   received = ReceiveAll(conn, buffer, content_length);
   if (received < content_length) {
     PrintF("Error %d\n", Socket::LastError());
-    return SmartPointer<char>();
+    return SmartArrayPointer<char>();
   }
   buffer[content_length] = '\0';
 
-  return SmartPointer<char>(buffer);
+  return SmartArrayPointer<char>(buffer);
 }
 
 
 bool DebuggerAgentUtil::SendConnectMessage(const Socket* conn,
                                            const char* embedding_host) {
   static const int kBufferSize = 80;
   char buffer[kBufferSize];  // Sending buffer.
   bool ok;
   int len;
 
@@ skipping 110 matching lines @@
       return total_received;
     }
     total_received += received;
   }
   return total_received;
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_DEBUGGER_SUPPORT