Replace JSON (de)serialization of extension messages with direct Value pickling.

chrome/browser/extensions/api/messaging/native_message_process_host.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/messaging/native_message_process_host.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/files/file_path.h"
+#include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/process_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/messaging/native_messaging_host_manifest.h"
 #include "chrome/browser/extensions/api/messaging/native_process_launcher.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "extensions/common/constants.h"
 #include "googleurl/src/gurl.h"
@@ skipping 16 matching lines @@
 const size_t kReadBufferSize = 4096;
 
 const char kFailedToStartError[] = "Failed to start native messaging host.";
 const char kInvalidNameError[] =
     "Invalid native messaging host name specified.";
 const char kNotFoundError[] = "Specified native messaging host not found.";
 const char kForbiddenError[] =
     "Access to the specified native messaging host is forbidden.";
 const char kHostInputOuputError[] =
     "Error when communicating with the native messaging host.";
+const char kInvalidJsonError[] =
+    "Message must be valid JSON";
 
 }  // namespace
 
 namespace extensions {
 
 NativeMessageProcessHost::NativeMessageProcessHost(
     base::WeakPtr<Client> weak_client_ui,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
@@ skipping 206 matching lines @@
     if (message_size > kMaximumMessageSize) {
       LOG(ERROR) << "Native Messaging host tried sending a message that is "
                  << message_size << " bytes long.";
       Close(kHostInputOuputError);
       return;
     }
 
     if (incoming_data_.size() < message_size + kMessageHeaderSize)
       return;
 
+    scoped_ptr<base::ListValue> message(new base::ListValue());
+    {
+      std::string message_as_json =
+          incoming_data_.substr(kMessageHeaderSize, message_size);
+      int error_code;
+      std::string error_message;
+      scoped_ptr<base::Value> message_as_value(
+          base::JSONReader::ReadAndReturnError(message_as_json,
+                                               0,  // no flags
+                                               &error_code,
+                                               &error_message));
+      if (!message_as_value) {
+        base::JSONReader::JsonParseError parse_error =
+            static_cast<base::JSONReader::JsonParseError>(error_code);
+        LOG(ERROR) << "Native Messaging host sent message with invalid JSON \""
+                   << message_as_json << "\": " << error_message << " ("
+                   << base::JSONReader::ErrorCodeToString(parse_error) << "), "
+                   << "message size " << message_size << ", "
+                   << "incoming data size " << incoming_data_.size() << ".";
+        Close(kInvalidJsonError);
+        return;
+      }
+      message->Append(message_as_value.release());
+    }
+
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&Client::PostMessageFromNativeProcess, weak_client_ui_,
             destination_port_,
-            incoming_data_.substr(kMessageHeaderSize, message_size)));
+            base::Passed(&message)));
 
     incoming_data_.erase(0, kMessageHeaderSize + message_size);
   }
 }
 
 void NativeMessageProcessHost::DoWrite() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   while (!write_pending_ && !closed_) {
     if (!current_write_buffer_.get() ||
@@ skipping 47 matching lines @@
     closed_ = true;
     read_stream_.reset();
     write_stream_.reset();
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&Client::CloseChannel, weak_client_ui_,
                    destination_port_, error_message));
   }
 }
 
 }  // namespace extensions