Minor cleanup in SandboxIPCHandler and ZygoteMain.

content/browser/renderer_host/sandbox_ipc_linux.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 "content/browser/renderer_host/sandbox_ipc_linux.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ skipping 203 matching lines @@
     base::PickleIterator iter,
     const std::vector<base::ScopedFD>& fds) {
   uint32_t index;
   if (!iter.ReadUInt32(&index))
     return;
   if (index >= static_cast<uint32_t>(paths_.size()))
     return;
   const int result_fd = open(paths_[index].c_str(), O_RDONLY);
 
   base::Pickle reply;
-  if (result_fd == -1) {
-    reply.WriteBool(false);
-  } else {
-    reply.WriteBool(true);
-  }
+  reply.WriteBool(result_fd != -1);
 
   // The receiver will have its own access to the file, so we will close it
   // after this send.
   SendRendererReply(fds, reply, result_fd);
 
   if (result_fd >= 0) {
     int err = IGNORE_EINTR(close(result_fd));
     DCHECK(!err);
   }
 }
@@ skipping 25 matching lines @@
   reply.WriteBool(fallback_font.is_bold);
   reply.WriteBool(fallback_font.is_italic);
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleGetStyleForStrike(
     int fd,
     base::PickleIterator iter,
     const std::vector<base::ScopedFD>& fds) {
   std::string family;
-  bool bold, italic;
+  bool bold;
+  bool italic;
   uint16_t pixel_size;
 
   if (!iter.ReadString(&family) ||
       !iter.ReadBool(&bold) ||
       !iter.ReadBool(&italic) ||
       !iter.ReadUInt16(&pixel_size)) {
     return;
   }
 
   gfx::FontRenderParamsQuery query;
   query.families.push_back(family);
   query.pixel_size = pixel_size;
   query.style = italic ? gfx::Font::ITALIC : 0;
   query.weight = bold ? gfx::Font::Weight::BOLD : gfx::Font::Weight::NORMAL;
-  const gfx::FontRenderParams params = gfx::GetFontRenderParams(query, NULL);
+  const gfx::FontRenderParams params = gfx::GetFontRenderParams(query, nullptr);
 
   // These are passed as ints since they're interpreted as tri-state chars in
   // Blink.
   base::Pickle reply;
   reply.WriteInt(params.use_bitmaps);
   reply.WriteInt(params.autohinter);
   reply.WriteInt(params.hinting != gfx::FontRenderParams::HINTING_NONE);
   reply.WriteInt(ConvertHinting(params.hinting));
   reply.WriteInt(params.antialiasing);
   reply.WriteInt(ConvertSubpixelRendering(params.subpixel_rendering));
@@ skipping 13 matching lines @@
     return;
 
   time_t time;
   memcpy(&time, time_string.data(), sizeof(time));
   // We use localtime here because we need the tm_zone field to be filled
   // out. Since we are a single-threaded process, this is safe.
   const struct tm* expanded_time = localtime(&time);
 
   std::string result_string;
   const char* time_zone_string = "";
-  if (expanded_time != NULL) {
+  if (expanded_time) {
     result_string = std::string(reinterpret_cast<const char*>(expanded_time),
                                 sizeof(struct tm));
     time_zone_string = expanded_time->tm_zone;
   }
 
   base::Pickle reply;
   reply.WriteString(result_string);
   reply.WriteString(time_zone_string);
   SendRendererReply(fds, reply, -1);
 }
@@ skipping 15 matching lines @@
     shm_fd = shm.handle().fd;
   base::Pickle reply;
   SendRendererReply(fds, reply, shm_fd);
 }
 
 void SandboxIPCHandler::HandleMatchWithFallback(
     int fd,
     base::PickleIterator iter,
     const std::vector<base::ScopedFD>& fds) {
   std::string face;
-  bool is_bold, is_italic;
-  uint32_t charset, fallback_family;
+  bool is_bold;
+  bool is_italic;
+  uint32_t charset;
+  uint32_t fallback_family;
 
   if (!iter.ReadString(&face) || face.empty() ||
       !iter.ReadBool(&is_bold) ||
       !iter.ReadBool(&is_italic) ||
       !iter.ReadUInt32(&charset) ||
       !iter.ReadUInt32(&fallback_family)) {
     return;
   }
 
   int font_fd = MatchFontFaceWithFallback(
@@ skipping 45 matching lines @@
 }
 
 SandboxIPCHandler::~SandboxIPCHandler() {
   if (IGNORE_EINTR(close(lifeline_fd_)) < 0)
     PLOG(ERROR) << "close";
   if (IGNORE_EINTR(close(browser_socket_)) < 0)
     PLOG(ERROR) << "close";
 }
 
 }  // namespace content