Add DEPS include rules so we don't accidentally use base

ppapi/tests/test_transport.cc

 // Copyright (c) 2011 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 "ppapi/tests/test_transport.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <list>
@@ skipping 22 matching lines @@
 const char kTestChannelName[] = "test";
 const int kReadBufferSize = 65536;
 
 class StreamReader {
  public:
   StreamReader(pp::Transport_Dev* transport,
                int expected_size,
                pp::CompletionCallback done_callback)
       : expected_size_(expected_size),
         done_callback_(done_callback),
-        ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
+        PP_ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
         transport_(transport),
         received_size_(0) {
     Read();
   }
 
   const std::list<std::vector<char> >& received() { return received_; }
   std::list<std::string> errors() { return errors_; }
 
  private:
   void Read() {
@@ skipping 35 matching lines @@
   pp::CompletionCallbackFactory<StreamReader> callback_factory_;
   pp::Transport_Dev* transport_;
   std::vector<char> buffer_;
   std::list<std::vector<char> > received_;
   int received_size_;
   std::list<std::string> errors_;
 };
 
 }  // namespace
 
+TestTransport::~TestTransport() {
+  delete transport1_;
+  delete transport2_;
+}
+
 bool TestTransport::Init() {
   transport_interface_ = reinterpret_cast<PPB_Transport_Dev const*>(
       pp::Module::Get()->GetBrowserInterface(PPB_TRANSPORT_DEV_INTERFACE));
   return transport_interface_ && InitTestingInterface();
 }
 
 void TestTransport::RunTests(const std::string& filter) {
   RUN_TEST(Create, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
   RUN_TEST(SetProperty, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(SendDataUdp, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(SendDataTcp, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(ConnectAndCloseUdp, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(ConnectAndCloseTcp, filter);
 }
 
 std::string TestTransport::InitTargets(PP_TransportType type) {
-  transport1_.reset(new pp::Transport_Dev(instance_, kTestChannelName, type));
-  transport2_.reset(new pp::Transport_Dev(instance_, kTestChannelName, type));
+  transport1_ = new pp::Transport_Dev(instance_, kTestChannelName, type);
+  transport2_ = new pp::Transport_Dev(instance_, kTestChannelName, type);
 
-  ASSERT_TRUE(transport1_.get() != NULL);
-  ASSERT_TRUE(transport2_.get() != NULL);
+  ASSERT_NE(NULL, transport1_);
+  ASSERT_NE(NULL, transport2_);
 
   PASS();
 }
 
 std::string TestTransport::Connect() {
   TestCompletionCallback connect_cb1(instance_->pp_instance());
   TestCompletionCallback connect_cb2(instance_->pp_instance());
   ASSERT_EQ(transport1_->Connect(connect_cb1), PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(transport2_->Connect(connect_cb2), PP_OK_COMPLETIONPENDING);
 
@@ skipping 17 matching lines @@
   ASSERT_EQ(connect_cb1.WaitForResult(), PP_OK);
   ASSERT_EQ(connect_cb2.WaitForResult(), PP_OK);
 
   ASSERT_TRUE(transport1_->IsWritable());
   ASSERT_TRUE(transport2_->IsWritable());
 
   PASS();
 }
 
 std::string TestTransport::Clean() {
-  transport1_.reset();
-  transport2_.reset();
+  delete transport1_;
+  transport1_ = NULL;
+  delete transport2_;
+  transport2_ = NULL;
 
   PASS();
 }
 
 std::string TestTransport::TestCreate() {
   RUN_SUBTEST(InitTargets(PP_TRANSPORTTYPE_DATAGRAM));
 
   Clean();
 
   PASS();
@@ skipping 64 matching lines @@
 // that at least some packets are received (some packets may be lost).
 std::string TestTransport::TestSendDataUdp() {
   RUN_SUBTEST(InitTargets(PP_TRANSPORTTYPE_DATAGRAM));
   RUN_SUBTEST(Connect());
 
   const int kNumPackets = 100;
   const int kSendBufferSize = 1200;
   const int kUdpWaitTimeMs = 1000;  // 1 second.
 
   TestCompletionCallback done_cb(instance_->pp_instance());
-  StreamReader reader(transport1_.get(), kSendBufferSize * kNumPackets,
-                      done_cb);
+  StreamReader reader(transport1_, kSendBufferSize * kNumPackets, done_cb);
 
   std::map<int, std::vector<char> > sent_packets;
   for (int i = 0; i < kNumPackets; ++i) {
     std::vector<char> send_buffer(kSendBufferSize);
     for (size_t j = 0; j < send_buffer.size(); ++j) {
       send_buffer[j] = rand() % 256;
     }
     // Put packet index in the beginning.
     memcpy(&send_buffer[0], &i, sizeof(i));
 
@@ skipping 30 matching lines @@
 
 // Creating reliable (TCP-like) connection and try sending data over
 // it. Verify that all data is received correctly.
 std::string TestTransport::TestSendDataTcp() {
   RUN_SUBTEST(InitTargets(PP_TRANSPORTTYPE_STREAM));
   RUN_SUBTEST(Connect());
 
   const int kTcpSendSize = 100000;
 
   TestCompletionCallback done_cb(instance_->pp_instance());
-  StreamReader reader(transport1_.get(), kTcpSendSize,
-                      done_cb);
+  StreamReader reader(transport1_, kTcpSendSize, done_cb);
 
   std::vector<char> send_buffer(kTcpSendSize);
   for (size_t j = 0; j < send_buffer.size(); ++j) {
     send_buffer[j] = rand() % 256;
   }
 
   int pos = 0;
   while (pos < static_cast<int>(send_buffer.size())) {
     TestCompletionCallback send_cb(instance_->pp_instance(), force_async_);
     int result = transport2_->Send(
@@ skipping 56 matching lines @@
   // Close the transport and verify that callback is aborted.
   ASSERT_EQ(transport1_->Close(), PP_OK);
 
   ASSERT_EQ(recv_cb.run_count(), 1);
   ASSERT_EQ(recv_cb.result(), PP_ERROR_ABORTED);
 
   Clean();
 
   PASS();
 }