Replace OS_LINUX ifdefs with OS_POSIX & !OS_MACOSX, TOOLKIT_USES_GTK, or

content/browser/gpu/gpu_process_host.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 "content/browser/gpu/gpu_process_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_piece.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu/gpu_data_manager.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/common/content_switches.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/gpu/gpu_child_thread.h"
 #include "content/gpu/gpu_process.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_switches.h"
 
-#if defined(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
 #include "ui/gfx/gtk_native_view_id_manager.h"
-#endif  // defined(OS_LINUX)
+#endif
 
 namespace {
 
 enum GPUProcessLifetimeEvent {
   LAUNCHED,
   DIED_FIRST_TIME,
   DIED_SECOND_TIME,
   DIED_THIRD_TIME,
   DIED_FOURTH_TIME,
   GPU_PROCESS_LIFETIME_EVENT_MAX
 };
 
 // A global map from GPU process host ID to GpuProcessHost.
 static IDMap<GpuProcessHost> g_hosts_by_id;
 
 // Number of times the gpu process has crashed in the current browser session.
 static int g_gpu_crash_count = 0;
 
 // Maximum number of times the gpu process is allowed to crash in a session.
 // Once this limit is reached, any request to launch the gpu process will fail.
 static const int kGpuMaxCrashCount = 3;
 
 int g_last_host_id = 0;
 
-#if defined(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
 
 class ReleasePermanentXIDDispatcher: public Task {
  public:
   explicit ReleasePermanentXIDDispatcher(gfx::PluginWindowHandle surface);
   void Run();
  private:
   gfx::PluginWindowHandle surface_;
 };
 
 ReleasePermanentXIDDispatcher::ReleasePermanentXIDDispatcher(
@@ skipping 15 matching lines @@
       renderer_id, cause);
   if (host) {
     host->Send(message);
   } else {
     delete message;
   }
 }
 
 }  // anonymous namespace
 
-#if defined(OS_LINUX) && !defined(TOUCH_UI)
+#if defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
 // Used to put a lock on surfaces so that the window to which the GPU
 // process is drawing to doesn't disappear while it is drawing when
 // a tab is closed.
 class GpuProcessHost::SurfaceRef {
  public:
   explicit SurfaceRef(gfx::PluginWindowHandle surface);
   ~SurfaceRef();
  private:
   gfx::PluginWindowHandle surface_;
 };
 
 GpuProcessHost::SurfaceRef::SurfaceRef(gfx::PluginWindowHandle surface)
     : surface_(surface) {
   GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
   if (!manager->AddRefPermanentXID(surface_)) {
     LOG(ERROR) << "Surface " << surface << " cannot be referenced.";
   }
 }
 
 GpuProcessHost::SurfaceRef::~SurfaceRef() {
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           new ReleasePermanentXIDDispatcher(surface_));
 }
-#endif  // defined(OS_LINUX) && !defined(TOUCH_UI)
+#endif  // defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
 
 // This class creates a GPU thread (instead of a GPU process), when running
 // with --in-process-gpu or --single-process.
 class GpuMainThread : public base::Thread {
  public:
   explicit GpuMainThread(const std::string& channel_id)
       : base::Thread("Chrome_InProcGpuThread"),
         channel_id_(channel_id),
         gpu_process_(NULL),
         child_thread_(NULL) {
@@ skipping 242 matching lines @@
 
 void GpuProcessHost::CreateViewCommandBuffer(
     gfx::PluginWindowHandle compositing_surface,
     int32 render_view_id,
     int32 renderer_id,
     const GPUCreateCommandBufferConfig& init_params,
     CreateCommandBufferCallback* callback) {
   DCHECK(CalledOnValidThread());
   linked_ptr<CreateCommandBufferCallback> wrapped_callback(callback);
 
-#if defined(OS_LINUX) && !defined(TOUCH_UI)
+#if defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
   ViewID view_id(renderer_id, render_view_id);
 
   // There should only be one such command buffer (for the compositor).  In
   // practice, if the GPU process lost a context, GraphicsContext3D with
   // associated command buffer and view surface will not be gone until new
   // one is in place and all layers are reattached.
   linked_ptr<SurfaceRef> surface_ref;
   SurfaceRefMap::iterator it = surface_refs_.find(view_id);
   if (it != surface_refs_.end())
     surface_ref = (*it).second;
   else
     surface_ref.reset(new SurfaceRef(compositing_surface));
-#endif  // defined(OS_LINUX) && defined(TOUCH_UI)
+#endif  // defined(TOOLKIT_USES_GTK) && defined(TOUCH_UI)
 
   if (compositing_surface != gfx::kNullPluginWindow &&
       Send(new GpuMsg_CreateViewCommandBuffer(
           compositing_surface, render_view_id, renderer_id, init_params))) {
     create_command_buffer_requests_.push(wrapped_callback);
-#if defined(OS_LINUX) && !defined(TOUCH_UI)
+#if defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
     surface_refs_.insert(std::pair<ViewID, linked_ptr<SurfaceRef> >(
         view_id, surface_ref));
-#endif  // defined(OS_LINUX) && !defined(TOUCH_UI)
+#endif
   } else {
     CreateCommandBufferError(wrapped_callback.release(), MSG_ROUTING_NONE);
   }
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle) {
   // The GPU process should have launched at this point and this object should
   // have been notified of its process handle.
   DCHECK(gpu_process_);
@@ skipping 38 matching lines @@
     if (route_id == MSG_ROUTING_NONE)
       CreateCommandBufferError(callback.release(), route_id);
     else
       callback->Run(route_id);
   }
 }
 
 void GpuProcessHost::OnDestroyCommandBuffer(
     gfx::PluginWindowHandle window, int32 renderer_id,
     int32 render_view_id) {
-#if defined(OS_LINUX) && !defined(TOUCH_UI)
+#if defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
   ViewID view_id(renderer_id, render_view_id);
   SurfaceRefMap::iterator it = surface_refs_.find(view_id);
   if (it != surface_refs_.end())
     surface_refs_.erase(it);
-#endif  // defined(OS_LINUX) && !defined(TOUCH_UI)
+#endif  // defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
 }
 
 void GpuProcessHost::OnGraphicsInfoCollected(const GPUInfo& gpu_info) {
   GpuDataManager::GetInstance()->UpdateGpuInfo(gpu_info);
 }
 
 bool GpuProcessHost::CanShutdown() {
   return true;
 }
 
@@ skipping 137 matching lines @@
     CreateCommandBufferCallback* callback, int32 route_id) {
   scoped_ptr<GpuProcessHost::CreateCommandBufferCallback>
     wrapped_callback(callback);
   callback->Run(route_id);
 }
 
 void GpuProcessHost::SynchronizeError(SynchronizeCallback* callback) {
   scoped_ptr<SynchronizeCallback> wrapped_callback(callback);
   wrapped_callback->Run();
 }