Make miscellaneous_bindings and event_bindings Required as needed. Previously

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);
+      scoped_ptr<base::Value> message_as_value(
+          base::JSONReader::Read(message_as_json));
+      if (!message_as_value) {
+        LOG(ERROR) << "Native Messaging host sent a message with invalid JSON";
+        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_ || !current_write_buffer_->BytesRemaining()) {
@@ skipping 45 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