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

chromeos/dbus/shill_third_party_vpn_driver_client_unittest.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 <string>
 
 #include "base/bind.h"
+#include "base/stl_util.h"
 #include "chromeos/dbus/shill_client_unittest_base.h"
 #include "chromeos/dbus/shill_third_party_vpn_driver_client.h"
 #include "chromeos/dbus/shill_third_party_vpn_observer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using testing::_;
 
 namespace chromeos {
 
 namespace {
 
 const char kExampleIPConfigPath[] = "/foo/bar";
 
 class MockShillThirdPartyVpnObserver : public ShillThirdPartyVpnObserver {
  public:
   MockShillThirdPartyVpnObserver() {}
   ~MockShillThirdPartyVpnObserver() override {}
-  MOCK_METHOD1(OnPacketReceived, void(const std::string& data));
+  MOCK_METHOD1(OnPacketReceived, void(const std::vector<char>& data));
   MOCK_METHOD1(OnPlatformMessage, void(uint32_t message));
 };
 
 }  // namespace
 
 class ShillThirdPartyVpnDriverClientTest : public ShillClientUnittestBase {
  public:
   ShillThirdPartyVpnDriverClientTest()
       : ShillClientUnittestBase(shill::kFlimflamThirdPartyVpnInterface,
                                 dbus::ObjectPath(kExampleIPConfigPath)) {}
@@ skipping 15 matching lines @@
                       const std::string& error_message) {
     ADD_FAILURE() << error_name << ": " << error_message;
   }
 
  protected:
   scoped_ptr<ShillThirdPartyVpnDriverClient> client_;
 };
 
 TEST_F(ShillThirdPartyVpnDriverClientTest, PlatformSignal) {
   uint32_t connected_state = 123456;
-  const int kPacketSize = 5;
-  std::string data_packet(1, kPacketSize);
+  const size_t kPacketSize = 5;
+  std::vector<char> data_packet(kPacketSize, 1);
   dbus::Signal pmessage_signal(shill::kFlimflamThirdPartyVpnInterface,
                                shill::kOnPlatformMessageFunction);
   {
     dbus::MessageWriter writer(&pmessage_signal);
     writer.AppendUint32(connected_state);
   }
 
   dbus::Signal preceived_signal(shill::kFlimflamThirdPartyVpnInterface,
                                 shill::kOnPacketReceivedFunction);
   {
     dbus::MessageWriter writer(&preceived_signal);
     writer.AppendArrayOfBytes(
-        reinterpret_cast<const unsigned char*>(data_packet.data()),
+        reinterpret_cast<const uint8_t*>(vector_as_array(&data_packet)),
         data_packet.size());
   }
 
   // Expect each signal to be triggered once.
   MockShillThirdPartyVpnObserver observer;
   EXPECT_CALL(observer, OnPlatformMessage(connected_state)).Times(1);
   EXPECT_CALL(observer, OnPacketReceived(data_packet)).Times(1);
 
   client_->AddShillThirdPartyVpnObserver(kExampleIPConfigPath, &observer);
 
@@ skipping 74 matching lines @@
       base::Bind(&ShillThirdPartyVpnDriverClientTest::MockSuccess,
                  base::Unretained(this)),
       base::Bind(&Failure));
 
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ShillThirdPartyVpnDriverClientTest, SendPacket) {
   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
-  const std::string data(5, 0);
+  const size_t kPacketSize = 5;
+  const std::vector<char> data(kPacketSize, 0);
 
   EXPECT_CALL(*this, MockSuccess()).Times(1);
 
   PrepareForMethodCall(shill::kSendPacketFunction,
-                       base::Bind(&ExpectArrayOfBytesArgument, data),
+                       base::Bind(&ExpectArrayOfBytesArgument,
+                                  std::string(data.begin(), data.end())),
                        response.get());
 
   client_->SendPacket(
       kExampleIPConfigPath, data,
       base::Bind(&ShillThirdPartyVpnDriverClientTest::MockSuccess,
                  base::Unretained(this)),
       base::Bind(&Failure));
 
   message_loop_.RunUntilIdle();
 }
 
 }  // namespace chromeos