Cleanup: Remove wstring methods from base::Pickle.

ipc/ipc_fuzzing_tests.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 <stdio.h>
 #include <string>
 #include <sstream>
 
 #include "base/message_loop/message_loop.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "ipc/ipc_test_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // IPC messages for testing ----------------------------------------------------
 
 #define IPC_MESSAGE_IMPL
 #include "ipc/ipc_message_macros.h"
 
 #define IPC_MESSAGE_START TestMsgStart
 
-// Generic message class that is an int followed by a wstring.
-IPC_MESSAGE_CONTROL2(MsgClassIS, int, std::wstring)
+// Generic message class that is an int followed by a string16.
+IPC_MESSAGE_CONTROL2(MsgClassIS, int, base::string16)
 
-// Generic message class that is a wstring followed by an int.
-IPC_MESSAGE_CONTROL2(MsgClassSI, std::wstring, int)
+// Generic message class that is a string16 followed by an int.
+IPC_MESSAGE_CONTROL2(MsgClassSI, base::string16, int)
 
 // Message to create a mutex in the IPC server, using the received name.
-IPC_MESSAGE_CONTROL2(MsgDoMutex, std::wstring, int)
+IPC_MESSAGE_CONTROL2(MsgDoMutex, base::string16, int)
 
 // Used to generate an ID for a message that should not exist.
 IPC_MESSAGE_CONTROL0(MsgUnhandled)
 
 // -----------------------------------------------------------------------------
 
 namespace {
 
 TEST(IPCMessageIntegrity, ReadBeyondBufferStr) {
-  //This was BUG 984408.
+  // This was BUG 984408.
   uint32 v1 = kuint32max - 1;
   int v2 = 666;
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
   EXPECT_TRUE(m.WriteInt(v1));
   EXPECT_TRUE(m.WriteInt(v2));
 
   PickleIterator iter(m);
   std::string vs;
   EXPECT_FALSE(iter.ReadString(&vs));
 }
 
-TEST(IPCMessageIntegrity, ReadBeyondBufferWStr) {
-  //This was BUG 984408.
+TEST(IPCMessageIntegrity, ReadBeyondBufferStr16) {
+  // This was BUG 984408.
   uint32 v1 = kuint32max - 1;
   int v2 = 777;
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
   EXPECT_TRUE(m.WriteInt(v1));
   EXPECT_TRUE(m.WriteInt(v2));
 
   PickleIterator iter(m);
-  std::wstring vs;
-  EXPECT_FALSE(iter.ReadWString(&vs));
+  base::string16 vs;
+  EXPECT_FALSE(iter.ReadString16(&vs));
 }
 
 TEST(IPCMessageIntegrity, ReadBytesBadIterator) {
   // This was BUG 1035467.
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
   EXPECT_TRUE(m.WriteInt(1));
   EXPECT_TRUE(m.WriteInt(2));
 
   PickleIterator iter(m);
   const char* data = NULL;
@@ skipping 73 matching lines @@
       IPC_END_MESSAGE_MAP()
       if (pending_messages_) {
         // Probably a problem de-serializing the message.
         ReplyMsgNotHandled(msg.type());
       }
     }
     return true;
   }
 
  private:
-  void OnMsgClassISMessage(int value, const std::wstring& text) {
+  void OnMsgClassISMessage(int value, const base::string16& text) {
     UseData(MsgClassIS::ID, value, text);
     RoundtripAckReply(FUZZER_ROUTING_ID, MsgClassIS::ID, value);
     Cleanup();
   }
 
-  void OnMsgClassSIMessage(const std::wstring& text, int value) {
+  void OnMsgClassSIMessage(const base::string16& text, int value) {
     UseData(MsgClassSI::ID, value, text);
     RoundtripAckReply(FUZZER_ROUTING_ID, MsgClassSI::ID, value);
     Cleanup();
   }
 
   bool RoundtripAckReply(int routing, uint32 type_id, int reply) {
     IPC::Message* message = new IPC::Message(routing, type_id,
                                              IPC::Message::PRIORITY_NORMAL);
     message->WriteInt(reply + 1);
     message->WriteInt(reply);
     return other_->Send(message);
   }
 
   void Cleanup() {
     --message_count_;
     --pending_messages_;
     if (0 == message_count_)
       base::MessageLoop::current()->Quit();
   }
 
   void ReplyMsgNotHandled(uint32 type_id) {
     RoundtripAckReply(FUZZER_ROUTING_ID, MsgUnhandled::ID, type_id);
     Cleanup();
   }
 
-  void UseData(int caller, int value, const std::wstring& text) {
-    std::wostringstream wos;
-    wos << L"IPC fuzzer:" << caller << " [" << value << L" " << text << L"]\n";
-    std::wstring output = wos.str();
-    LOG(WARNING) << output.c_str();
-  };
+  void UseData(int caller, int value, const base::string16& text) {
+    std::ostringstream os;
+    os << "IPC fuzzer:" << caller << " [" << value << " "
+       << base::UTF16ToUTF8(text) << "]\n";
+    std::string output = os.str();
+    LOG(WARNING) << output;
+  }
 
   int message_count_;
   int pending_messages_;
 };
 
 class FuzzerClientListener : public SimpleListener {
  public:
   FuzzerClientListener() : last_msg_(NULL) {
   }
 
@@ skipping 28 matching lines @@
   }
 
  private:
   bool MsgHandlerInternal(uint32 type_id) {
     base::MessageLoop::current()->Run();
     if (NULL == last_msg_)
       return false;
     if (FUZZER_ROUTING_ID != last_msg_->routing_id())
       return false;
     return (type_id == last_msg_->type());
-  };
+  }
 
   IPC::Message* last_msg_;
 };
 
 // Runs the fuzzing server child mode. Returns when the preset number of
 // messages have been received.
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(FuzzServerClient) {
   base::MessageLoopForIO main_message_loop;
   FuzzerServerListener listener;
   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
@@ skipping 14 matching lines @@
   Init("FuzzServerClient");
 
   FuzzerClientListener listener;
   CreateChannel(&listener);
   listener.Init(channel());
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   IPC::Message* msg = NULL;
   int value = 43;
-  msg = new MsgClassIS(value, L"expect 43");
+  msg = new MsgClassIS(value, base::ASCIIToUTF16("expect 43"));
   sender()->Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(value, MsgClassIS::ID));
 
-  msg = new MsgClassSI(L"expect 44", ++value);
+  msg = new MsgClassSI(base::ASCIIToUTF16("expect 44"), ++value);
   sender()->Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(value, MsgClassSI::ID));
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 // This test uses a payload that is smaller than expected. This generates an
 // error while unpacking the IPC buffer which in debug trigger an assertion and
 // in release is ignored (!). Right after we generate another valid IPC to make
 // sure framing is working properly.
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 TEST_F(IPCFuzzingTest, MsgBadPayloadShort) {
   Init("FuzzServerClient");
 
   FuzzerClientListener listener;
   CreateChannel(&listener);
   listener.Init(channel());
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   IPC::Message* msg = new IPC::Message(MSG_ROUTING_CONTROL, MsgClassIS::ID,
                                        IPC::Message::PRIORITY_NORMAL);
   msg->WriteInt(666);
   sender()->Send(msg);
   EXPECT_TRUE(listener.ExpectMsgNotHandled(MsgClassIS::ID));
 
-  msg = new MsgClassSI(L"expect one", 1);
+  msg = new MsgClassSI(base::ASCIIToUTF16("expect one"), 1);
   sender()->Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(1, MsgClassSI::ID));
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 #endif
 
 // This test uses a payload that has too many arguments, but so the payload size
 // is big enough so the unpacking routine does not generate an error as in the
 // case of MsgBadPayloadShort test. This test does not pinpoint a flaw (per se)
 // as by design we don't carry type information on the IPC message.
 TEST_F(IPCFuzzingTest, MsgBadPayloadArgs) {
   Init("FuzzServerClient");
 
   FuzzerClientListener listener;
   CreateChannel(&listener);
   listener.Init(channel());
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   IPC::Message* msg = new IPC::Message(MSG_ROUTING_CONTROL, MsgClassSI::ID,
                                        IPC::Message::PRIORITY_NORMAL);
-  msg->WriteWString(L"d");
+  msg->WriteString16(base::ASCIIToUTF16("d"));
   msg->WriteInt(0);
   msg->WriteInt(0x65);  // Extra argument.
 
   sender()->Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(0, MsgClassSI::ID));
 
   // Now send a well formed message to make sure the receiver wasn't
   // thrown out of sync by the extra argument.
-  msg = new MsgClassIS(3, L"expect three");
+  msg = new MsgClassIS(3, base::ASCIIToUTF16("expect three"));
   sender()->Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(3, MsgClassIS::ID));
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 }  // namespace