json_schema_compiler: Use std::vector<char> for binary values.

extensions/browser/api/vpn_provider/vpn_service.cc

 // Copyright 2014 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 "extensions/browser/api/vpn_provider/vpn_service.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 53 matching lines @@
   const std::string& extension_id() const { return extension_id_; }
   const std::string& configuration_name() const { return configuration_name_; }
   const std::string& key() const { return key_; }
   const std::string& service_path() const { return service_path_; }
   void set_service_path(const std::string& service_path) {
     service_path_ = service_path;
   }
   const std::string& object_path() const { return object_path_; }
 
   // ShillThirdPartyVpnObserver:
-  void OnPacketReceived(const std::string& data) override;
+  void OnPacketReceived(const std::vector<char>& data) override;
   void OnPlatformMessage(uint32_t message) override;
 
  private:
   const std::string extension_id_;
   const std::string configuration_name_;
   const std::string key_;
   const std::string object_path_;
 
   std::string service_path_;
 
@@ skipping 10 matching lines @@
     : extension_id_(extension_id),
       configuration_name_(configuration_name),
       key_(key),
       object_path_(shill::kObjectPathBase + key_),
       vpn_service_(vpn_service) {
 }
 
 VpnService::VpnConfiguration::~VpnConfiguration() {
 }
 
-void VpnService::VpnConfiguration::OnPacketReceived(const std::string& data) {
+void VpnService::VpnConfiguration::OnPacketReceived(
+    const std::vector<char>& data) {
   if (!vpn_service_) {
     return;
   }
   scoped_ptr<base::ListValue> event_args =
       api_vpn::OnPacketReceived::Create(data);
   vpn_service_->SendSignalToExtension(
       extension_id_, api_vpn::OnPacketReceived::kEventName, event_args.Pass());
 }
 
 void VpnService::VpnConfiguration::OnPlatformMessage(uint32_t message) {
@@ skipping 236 matching lines @@
   if (!DoesActiveConfigurationExistAndIsAccessAuthorized(extension_id)) {
     failure.Run(std::string(), std::string("Unauthorized access."));
     return;
   }
 
   shill_client_->SetParameters(active_configuration_->object_path(), parameters,
                                success, failure);
 }
 
 void VpnService::SendPacket(const std::string& extension_id,
-                            const std::string& data,
+                            const std::vector<char>& data,
                             const SuccessCallback& success,
                             const FailureCallback& failure) {
   if (!DoesActiveConfigurationExistAndIsAccessAuthorized(extension_id)) {
     failure.Run(std::string(), std::string("Unauthorized access."));
     return;
   }
 
   if (data.empty()) {
     failure.Run(std::string(), std::string("Can't send an empty packet."));
     return;
@@ skipping 111 matching lines @@
   delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
 }  // namespace chromeos