Cleanup: Remove base::environment_vector and base::file_handle_mapping_vector to StudlyCaps.

content/browser/gpu/gpu_process_host.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/browser/gpu/gpu_process_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 182 matching lines @@
   // Don't grant further access to GPU if it is not allowed.
   GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance();
   if (gpu_data_manager != NULL && !gpu_data_manager->GpuAccessAllowed())
     return NULL;
 
   // The current policy is to ignore the renderer ID and use a single GPU
   // process (the first valid host in the host-id map) for all renderers. Later
   // this will be extended to allow the use of multiple GPU processes.
   for (IDMap<GpuProcessHost>::iterator it(g_hosts_by_id.Pointer());
        !it.IsAtEnd(); it.Advance()) {
-    GpuProcessHost *host = it.GetCurrentValue();
+    GpuProcessHost* host = it.GetCurrentValue();
 
     if (host->sandboxed() != (client_id != 0))
       continue;
 
     if (HostIsValid(host))
       return host;
   }
 
   if (cause == content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH)
     return NULL;
@@ skipping 23 matching lines @@
             &SendGpuProcessMessage, client_id, cause, message));
 }
 
 // static
 GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_id == 0)
     return NULL;
 
-  GpuProcessHost *host = g_hosts_by_id.Pointer()->Lookup(host_id);
+  GpuProcessHost* host = g_hosts_by_id.Pointer()->Lookup(host_id);
   if (HostIsValid(host))
     return host;
 
   return NULL;
 }
 
 GpuProcessHost::GpuProcessHost(int host_id, bool sandboxed)
     : host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
       in_process_(false),
@@ skipping 100 matching lines @@
   // of this child window. Unfortunately it might always be necessary for
   // Windows XP because we cannot share the backing store textures between
   // processes.
   options.message_loop_type = MessageLoop::TYPE_UI;
 #else
   options.message_loop_type = MessageLoop::TYPE_IO;
 #endif
     in_process_gpu_thread_->StartWithOptions(options);
 
     OnProcessLaunched();  // Fake a callback that the process is ready.
-  } else if (!LaunchGpuProcess(channel_id))
+  } else if (!LaunchGpuProcess(channel_id)) {
     return false;
+  }
 
   return Send(new GpuMsg_Initialize());
 }
 
 void GpuProcessHost::RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&RouteToGpuProcessHostUIShimTask, host_id_, message));
 }
@@ skipping 240 matching lines @@
 
   // If specified, prepend a launcher program to the command line.
   if (!gpu_launcher.empty())
     cmd_line->PrependWrapper(gpu_launcher);
 
   process_->Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       false,  // Never use the zygote (GPU plugin can't be sandboxed).
-      base::environment_vector(),
+      base::EnvironmentVector(),
 #endif
       cmd_line);
   process_launched_ = true;
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             LAUNCHED, GPU_PROCESS_LIFETIME_EVENT_MAX);
   return true;
 }
 
 void GpuProcessHost::SendOutstandingReplies() {
@@ skipping 13 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
   callback.Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }