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

chromeos/dbus/shill_third_party_vpn_driver_client.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 "chromeos/dbus/shill_third_party_vpn_driver_client.h"
 
 #include <string>

[bartfab (slow), 2015/01/19 10:08:38]

Nit: Already included by header.

[pneubeck (no reviews), 2015/01/19 17:13:46]

independent of the header, string is used in line 94 of this patchset.

[bartfab (slow), 2015/01/19 17:57:17]

The way we do IWYU is to not include a header that your .h file included
already.

[pneubeck (no reviews), 2015/01/19 18:04:28]

Done.

+#include <vector>

[bartfab (slow), 2015/01/19 10:08:38]

Nit: Already included by header.

[pneubeck (no reviews), 2015/01/19 17:13:46]

independent of the header vector is used in line 275 of this patchset.

[bartfab (slow), 2015/01/19 17:57:17]

The way we do IWYU is to not include a header that your .h file included
already.

[pneubeck (no reviews), 2015/01/19 18:04:28]

Done.

 
 #include "base/bind.h"
+#include "base/stl_util.h"
 #include "chromeos/dbus/shill_third_party_vpn_observer.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 29 matching lines @@
       const ShillClientHelper::ErrorCallback& error_callback) override;
 
   void UpdateConnectionState(
       const std::string& object_path_value,
       const uint32_t connection_state,
       const base::Closure& callback,
       const ShillClientHelper::ErrorCallback& error_callback) override;
 
   void SendPacket(
       const std::string& object_path_value,
-      const std::string& ip_packet,
+      const std::vector<char>& ip_packet,
       const base::Closure& callback,
       const ShillClientHelper::ErrorCallback& error_callback) override;
 
  protected:
   void Init(dbus::Bus* bus) override { bus_ = bus; }
 
   ShillThirdPartyVpnDriverClient::TestInterface* GetTestInterface() override {
     return nullptr;
   }
 
@@ skipping 168 matching lines @@
   dbus::MethodCall method_call(shill::kFlimflamThirdPartyVpnInterface,
                                shill::kUpdateConnectionStateFunction);
   dbus::MessageWriter writer(&method_call);
   writer.AppendUint32(connection_state);
   GetHelper(object_path_value)
       ->CallVoidMethodWithErrorCallback(&method_call, callback, error_callback);
 }
 
 void ShillThirdPartyVpnDriverClientImpl::SendPacket(
     const std::string& object_path_value,
-    const std::string& ip_packet,
+    const std::vector<char>& ip_packet,
     const base::Closure& callback,
     const ShillClientHelper::ErrorCallback& error_callback) {
   dbus::MethodCall method_call(shill::kFlimflamThirdPartyVpnInterface,
                                shill::kSendPacketFunction);
   dbus::MessageWriter writer(&method_call);
-  writer.AppendArrayOfBytes(reinterpret_cast<const uint8_t*>(ip_packet.data()),
-                            ip_packet.size());
+  writer.AppendArrayOfBytes(
+      reinterpret_cast<const uint8_t*>(vector_as_array(&ip_packet)),
+      ip_packet.size());
   GetHelper(object_path_value)
       ->CallVoidMethodWithErrorCallback(&method_call, callback, error_callback);
 }
 
 // static
 void ShillThirdPartyVpnDriverClientImpl::OnPacketReceived(
     base::WeakPtr<HelperInfo> helper_info,
     dbus::Signal* signal) {
   if (!helper_info || !helper_info->observer())
     return;
 
   dbus::MessageReader reader(signal);
   const uint8_t* data = nullptr;
   size_t length = 0;
   if (reader.PopArrayOfBytes(&data, &length)) {
     helper_info->observer()->OnPacketReceived(
-        std::string(reinterpret_cast<const char*>(data), length));
+        std::vector<char>(data, data + length));

[bartfab (slow), 2015/01/19 10:08:38]

You assume that a |char| is exactly 8 bits in size. The C++ standard does not
guarantee this. It is true on major platforms but is not something you should
rely on. Why do you not use an std::vector<uint8_t>?

[pneubeck (no reviews), 2015/01/19 17:13:46]

as discussed, added a static assert

   }
 }
 
 // static
 void ShillThirdPartyVpnDriverClientImpl::OnPlatformMessage(
     base::WeakPtr<HelperInfo> helper_info,
     dbus::Signal* signal) {
   if (!helper_info || !helper_info->observer())
     return;
 
@@ skipping 47 matching lines @@
 
 ShillThirdPartyVpnDriverClient::~ShillThirdPartyVpnDriverClient() {
 }
 
 // static
 ShillThirdPartyVpnDriverClient* ShillThirdPartyVpnDriverClient::Create() {
   return new ShillThirdPartyVpnDriverClientImpl();
 }
 
 }  // namespace chromeos