Minor cleanup in SandboxIPCHandler and ZygoteMain.

content/zygote/zygote_main_linux.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 "content/zygote/zygote_main.h"
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <openssl/crypto.h>
 #include <openssl/rand.h>
@@ skipping 205 matching lines @@
 struct tm* localtime_override(const time_t* timep) __asm__ ("localtime");
 
 __attribute__ ((__visibility__("default")))
 struct tm* localtime_override(const time_t* timep) {
   if (g_am_zygote_or_renderer) {
     static struct tm time_struct;
     static char timezone_string[64];
     ProxyLocaltimeCallToBrowser(*timep, &time_struct, timezone_string,
                                 sizeof(timezone_string));
     return &time_struct;
-  } else {
-    CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
-                             InitLibcLocaltimeFunctions));
-    struct tm* res = g_libc_localtime(timep);
+  }
+
+  CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
+                           InitLibcLocaltimeFunctions));
+  struct tm* res = g_libc_localtime(timep);
 #if defined(MEMORY_SANITIZER)
-    if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
+  if (res) __msan_unpoison(res, sizeof(*res));
+  if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
-    return res;
-  }
+  return res;
 }
 
 // Use same trick to override localtime64(), localtime_r() and localtime64_r().
 __attribute__ ((__visibility__("default")))
 struct tm* localtime64_override(const time_t* timep) __asm__ ("localtime64");
 
 __attribute__ ((__visibility__("default")))
 struct tm* localtime64_override(const time_t* timep) {
   if (g_am_zygote_or_renderer) {
     static struct tm time_struct;
     static char timezone_string[64];
     ProxyLocaltimeCallToBrowser(*timep, &time_struct, timezone_string,
                                 sizeof(timezone_string));
     return &time_struct;
-  } else {
-    CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
-                             InitLibcLocaltimeFunctions));
-    struct tm* res = g_libc_localtime64(timep);
+  }
+
+  CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
+                           InitLibcLocaltimeFunctions));
+  struct tm* res = g_libc_localtime64(timep);
 #if defined(MEMORY_SANITIZER)
-    if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
+  if (res) __msan_unpoison(res, sizeof(*res));
+  if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
-    return res;
-  }
+  return res;
 }
 
 __attribute__ ((__visibility__("default")))
 struct tm* localtime_r_override(const time_t* timep,
                                 struct tm* result) __asm__ ("localtime_r");
 
 __attribute__ ((__visibility__("default")))
 struct tm* localtime_r_override(const time_t* timep, struct tm* result) {
   if (g_am_zygote_or_renderer) {
     ProxyLocaltimeCallToBrowser(*timep, result, NULL, 0);
     return result;
-  } else {
-    CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
-                             InitLibcLocaltimeFunctions));
-    struct tm* res = g_libc_localtime_r(timep, result);
+  }
+
+  CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
+                           InitLibcLocaltimeFunctions));
+  struct tm* res = g_libc_localtime_r(timep, result);
 #if defined(MEMORY_SANITIZER)
-    if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
+  if (res) __msan_unpoison(res, sizeof(*res));
+  if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
-    return res;
-  }
+  return res;
 }
 
 __attribute__ ((__visibility__("default")))
 struct tm* localtime64_r_override(const time_t* timep,
                                   struct tm* result) __asm__ ("localtime64_r");
 
 __attribute__ ((__visibility__("default")))
 struct tm* localtime64_r_override(const time_t* timep, struct tm* result) {
   if (g_am_zygote_or_renderer) {
     ProxyLocaltimeCallToBrowser(*timep, result, NULL, 0);
     return result;
-  } else {
-    CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
-                             InitLibcLocaltimeFunctions));
-    struct tm* res = g_libc_localtime64_r(timep, result);
+  }
+
+  CHECK_EQ(0, pthread_once(&g_libc_localtime_funcs_guard,
+                           InitLibcLocaltimeFunctions));
+  struct tm* res = g_libc_localtime64_r(timep, result);
 #if defined(MEMORY_SANITIZER)
-    if (res) __msan_unpoison(res, sizeof(*res));
-    if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
+  if (res) __msan_unpoison(res, sizeof(*res));
+  if (res->tm_zone) __msan_unpoison_string(res->tm_zone);
 #endif
-    return res;
-  }
+  return res;
 }
 
 #if defined(ENABLE_PLUGINS)
 // Loads the (native) libraries but does not initialize them (i.e., does not
 // call PPP_InitializeModule). This is needed by the zygote on Linux to get
 // access to the plugins before entering the sandbox.
 void PreloadPepperPlugins() {
   std::vector<PepperPluginInfo> plugins;
   ComputePepperPluginList(&plugins);
-  for (size_t i = 0; i < plugins.size(); ++i) {
-    if (!plugins[i].is_internal) {
+  for (const auto& plugin : plugins) {
+    if (!plugin.is_internal) {
       base::NativeLibraryLoadError error;
-      base::NativeLibrary library = base::LoadNativeLibrary(plugins[i].path,
+      base::NativeLibrary library = base::LoadNativeLibrary(plugin.path,
                                                             &error);
       VLOG_IF(1, !library) << "Unable to load plugin "
-                           << plugins[i].path.value() << " "
+                           << plugin.path.value() << " "
                            << error.ToString();
 
       (void)library;  // Prevent release-mode warning.
     }
   }
 }
 #endif
 
 // This function triggers the static and lazy construction of objects that need
 // to be created before imposing the sandbox.
@@ skipping 325 matching lines @@
   const bool namespace_sandbox_engaged = sandbox_flags & kSandboxLinuxUserNS;
   CHECK_EQ(using_namespace_sandbox, namespace_sandbox_engaged);
 
   Zygote zygote(sandbox_flags, std::move(fork_delegates), extra_children,
                 extra_fds);
   // This function call can return multiple times, once per fork().
   return zygote.ProcessRequests();
 }
 
 }  // namespace content