Update from https://crrev.com/333737

sandbox/linux/syscall_broker/broker_host.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 "sandbox/linux/syscall_broker/broker_host.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
@@ skipping 41 matching lines @@
     return syscall(__NR_openat, AT_FDCWD, pathname, flags, mode);
   }
 }
 
 // Open |requested_filename| with |flags| if allowed by our policy.
 // Write the syscall return value (-errno) to |write_pickle| and append
 // a file descriptor to |opened_files| if relevant.
 void OpenFileForIPC(const BrokerPolicy& policy,
                     const std::string& requested_filename,
                     int flags,
-                    Pickle* write_pickle,
+                    base::Pickle* write_pickle,
                     std::vector<int>* opened_files) {
   DCHECK(write_pickle);
   DCHECK(opened_files);
   const char* file_to_open = NULL;
   bool unlink_after_open = false;
   const bool safe_to_open_file = policy.GetFileNameIfAllowedToOpen(
       requested_filename.c_str(), flags, &file_to_open, &unlink_after_open);
 
   if (safe_to_open_file) {
     CHECK(file_to_open);
@@ skipping 11 matching lines @@
   } else {
     write_pickle->WriteInt(-policy.denied_errno());
   }
 }
 
 // Perform access(2) on |requested_filename| with mode |mode| if allowed by our
 // policy. Write the syscall return value (-errno) to |write_pickle|.
 void AccessFileForIPC(const BrokerPolicy& policy,
                       const std::string& requested_filename,
                       int mode,
-                      Pickle* write_pickle) {
+                      base::Pickle* write_pickle) {
   DCHECK(write_pickle);
   const char* file_to_access = NULL;
   const bool safe_to_access_file = policy.GetFileNameIfAllowedToAccess(
       requested_filename.c_str(), mode, &file_to_access);
 
   if (safe_to_access_file) {
     CHECK(file_to_access);
     int access_ret = access(file_to_access, mode);
     int access_errno = errno;
     if (!access_ret)
       write_pickle->WriteInt(0);
     else
       write_pickle->WriteInt(-access_errno);
   } else {
     write_pickle->WriteInt(-policy.denied_errno());
   }
 }
 
 // Handle a |command_type| request contained in |iter| and send the reply
 // on |reply_ipc|.
 // Currently COMMAND_OPEN and COMMAND_ACCESS are supported.
 bool HandleRemoteCommand(const BrokerPolicy& policy,
                          IPCCommand command_type,
                          int reply_ipc,
-                         PickleIterator iter) {
+                         base::PickleIterator iter) {
   // Currently all commands have two arguments: filename and flags.
   std::string requested_filename;
   int flags = 0;
   if (!iter.ReadString(&requested_filename) || !iter.ReadInt(&flags))
     return false;
 
-  Pickle write_pickle;
+  base::Pickle write_pickle;
   std::vector<int> opened_files;
 
   switch (command_type) {
     case COMMAND_ACCESS:
       AccessFileForIPC(policy, requested_filename, flags, &write_pickle);
       break;
     case COMMAND_OPEN:
       OpenFileForIPC(
           policy, requested_filename, flags, &write_pickle, &opened_files);
       break;
     default:
       LOG(ERROR) << "Invalid IPC command";
       break;
   }
 
   CHECK_LE(write_pickle.size(), kMaxMessageLength);
-  ssize_t sent = UnixDomainSocket::SendMsg(
+  ssize_t sent = base::UnixDomainSocket::SendMsg(
       reply_ipc, write_pickle.data(), write_pickle.size(), opened_files);
 
   // Close anything we have opened in this process.
   for (std::vector<int>::iterator it = opened_files.begin();
        it != opened_files.end();
        ++it) {
     int ret = IGNORE_EINTR(close(*it));
     DCHECK(!ret) << "Could not close file descriptor";
   }
 
@@ skipping 15 matching lines @@
 }
 
 // Handle a request on the IPC channel ipc_channel_.
 // A request should have a file descriptor attached on which we will reply and
 // that we will then close.
 // A request should start with an int that will be used as the command type.
 BrokerHost::RequestStatus BrokerHost::HandleRequest() const {
   ScopedVector<base::ScopedFD> fds;
   char buf[kMaxMessageLength];
   errno = 0;
-  const ssize_t msg_len =
-      UnixDomainSocket::RecvMsg(ipc_channel_.get(), buf, sizeof(buf), &fds);
+  const ssize_t msg_len = base::UnixDomainSocket::RecvMsg(
+      ipc_channel_.get(), buf, sizeof(buf), &fds);
 
   if (msg_len == 0 || (msg_len == -1 && errno == ECONNRESET)) {
     // EOF from the client, or the client died, we should die.
     return RequestStatus::LOST_CLIENT;
   }
 
   // The client should send exactly one file descriptor, on which we
   // will write the reply.
   // TODO(mdempsky): ScopedVector doesn't have 'at()', only 'operator[]'.
   if (msg_len < 0 || fds.size() != 1 || fds[0]->get() < 0) {
     PLOG(ERROR) << "Error reading message from the client";
     return RequestStatus::FAILURE;
   }
 
   base::ScopedFD temporary_ipc(fds[0]->Pass());
 
-  Pickle pickle(buf, msg_len);
-  PickleIterator iter(pickle);
+  base::Pickle pickle(buf, msg_len);
+  base::PickleIterator iter(pickle);
   int command_type;
   if (iter.ReadInt(&command_type)) {
     bool command_handled = false;
     // Go through all the possible IPC messages.
     switch (command_type) {
       case COMMAND_ACCESS:
       case COMMAND_OPEN:
         // We reply on the file descriptor sent to us via the IPC channel.
         command_handled = HandleRemoteCommand(
             broker_policy_, static_cast<IPCCommand>(command_type),
@@ skipping 13 matching lines @@
     NOTREACHED();
   }
 
   LOG(ERROR) << "Error parsing IPC request";
   return RequestStatus::FAILURE;
 }
 
 }  // namespace syscall_broker
 
 }  // namespace sandbox