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

ppapi/tests/test_file_io.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_file_io.h"
 
 #include <string.h>
 
-#include "base/memory/scoped_ptr.h"
+#include <vector>
+
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_file_io.h"
 #include "ppapi/c/trusted/ppb_file_io_trusted.h"
 #include "ppapi/cpp/file_io.h"
 #include "ppapi/cpp/file_ref.h"
 #include "ppapi/cpp/file_system.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/tests/test_utils.h"
@@ skipping 670 matching lines @@
   if (rv != PP_OK)
     return ReportError("FileIO::Write", rv);
 
   // Parallel read operations.
   const char* border = "__border__";
   const int32_t border_size = strlen(border);
 
   TestCompletionCallback callback_1(instance_->pp_instance(), force_async_);
   int32_t read_offset_1 = 0;
   int32_t size_1 = 3;
-  char* extended_buf_1 = new char[border_size * 2 + size_1];
-  scoped_array<char> extended_buf_1_deleter(extended_buf_1);
-  char* buf_1 = extended_buf_1 + border_size;
-  memcpy(extended_buf_1, border, border_size);
+  std::vector<char> extended_buf_1(border_size * 2 + size_1);
+  char* buf_1 = &extended_buf_1[border_size];
+  memcpy(&extended_buf_1[0], border, border_size);
   memcpy(buf_1 + size_1, border, border_size);
 
   TestCompletionCallback callback_2(instance_->pp_instance(), force_async_);
   int32_t read_offset_2 = size_1;
   int32_t size_2 = 9;
-  char* extended_buf_2 = new char[border_size * 2 + size_2];
-  scoped_array<char> extended_buf_2_deleter(extended_buf_2);
-  char* buf_2 = extended_buf_2 + border_size;
-  memcpy(extended_buf_2, border, border_size);
+  std::vector<char> extended_buf_2(border_size * 2 + size_2);
+  char* buf_2 = &extended_buf_2[border_size];
+  memcpy(&extended_buf_2[0], border, border_size);
   memcpy(buf_2 + size_2, border, border_size);
 
   int32_t rv_1 = PP_OK;
   int32_t rv_2 = PP_OK;
   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
     if (size_1 > 0) {
       rv_1 = file_io.Read(read_offset_1, buf_1, size_1, callback_1);
       if (rv_1 != PP_OK_COMPLETIONPENDING)
         return ReportError("FileIO::Read", rv_1);
     }
@@ skipping 26 matching lines @@
   // If |size_1| or |size_2| is less than 0, we have invoked wrong
   // callback(s).
   if (size_1 < 0 || size_2 < 0) {
     return std::string(
         "Parallel FileIO::Read operations have invoked wrong callbacks.");
   }
 
   // Make sure every read operation writes into the correct buffer.
   const char expected_result_1[] = "__border__abc__border__";
   const char expected_result_2[] = "__border__defghijkl__border__";
-  if (strncmp(extended_buf_1, expected_result_1,
+  if (strncmp(&extended_buf_1[0], expected_result_1,
               strlen(expected_result_1)) != 0 ||
-      strncmp(extended_buf_2, expected_result_2,
+      strncmp(&extended_buf_2[0], expected_result_2,
               strlen(expected_result_2)) != 0) {
     return std::string(
         "Parallel FileIO::Read operations have written into wrong buffers.");
   }
 
   PASS();
 }
 
 std::string TestFileIO::TestParallelWrites() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
@@ skipping 319 matching lines @@
     rv = callback.WaitForResult();
   if ((invalid_combination && rv == PP_OK) ||
       (!invalid_combination && ((rv == PP_OK) != create_if_doesnt_exist))) {
     return ReportOpenError(open_flags);
   }
 
   return std::string();
 }
 
 // TODO(viettrungluu): Test Close(). crbug.com/69457