Fix and separate out VSync code on Mac

Sending VSync parameters to the renderer was deleted in r286038. This
adds that back (the impact of that was fairly limited because the browser's
back-pressure effectively causes the VSync).

This also pulls the computation out of CompositingIOSurfaceMac, and
into a separate DisplayLinkMac class which is hung off of each
CompositingIOSurface instance. This results in fewer total display links,
though, in practice, only the links for animating visible tabs are
running.

BUG=340133

Review URL: https://codereview.chromium.org/152373002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@249054 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 230 insertions, 155 deletions

diff --git a/content/browser/renderer_host/compositing_iosurface_context_mac.h b/content/browser/renderer_host/compositing_iosurface_context_mac.h
index da9fc44..254d966 100644
--- a/content/browser/renderer_host/compositing_iosurface_context_mac.h
+++ b/content/browser/renderer_host/compositing_iosurface_context_mac.h
@@ -14,6 +14,7 @@
 #include "base/mac/scoped_nsobject.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "content/browser/renderer_host/display_link_mac.h"
 
 namespace content {
 
@@ -45,6 +46,8 @@ class CompositingIOSurfaceContext
 
   bool IsVendorIntel();
 
+  DisplayLinkMac* display_link() { return display_link_; }
+
  private:
   friend class base::RefCounted<CompositingIOSurfaceContext>;
 
@@ -53,6 +56,7 @@ class CompositingIOSurfaceContext
       NSOpenGLContext* nsgl_context,
       CGLContextObj clg_context,
       bool is_vsync_disabled_,
+      scoped_refptr<DisplayLinkMac> display_link,
       scoped_ptr<CompositingIOSurfaceShaderPrograms> shader_program_cache);
   ~CompositingIOSurfaceContext();
 
@@ -67,6 +71,9 @@ class CompositingIOSurfaceContext
   bool is_intel_;
   GLint screen_;
 
+  // Display link for getting vsync info.
+  scoped_refptr<DisplayLinkMac> display_link_;
+
   // The global map from window number and window ordering to
   // context data.
   typedef std::map<int, CompositingIOSurfaceContext*> WindowMap;
diff --git a/content/browser/renderer_host/compositing_iosurface_context_mac.mm b/content/browser/renderer_host/compositing_iosurface_context_mac.mm
index 4c6cbf1..d19472c 100644
--- a/content/browser/renderer_host/compositing_iosurface_context_mac.mm
+++ b/content/browser/renderer_host/compositing_iosurface_context_mac.mm
@@ -89,11 +89,18 @@ CompositingIOSurfaceContext::Get(int window_number) {
     return NULL;
   }
 
+  scoped_refptr<DisplayLinkMac> display_link = DisplayLinkMac::Create();
+  if (!display_link) {
+    LOG(ERROR) << "Failed to create display link for GL context.";
+    return NULL;
+  }
+
   return new CompositingIOSurfaceContext(
       window_number,
       nsgl_context.release(),
       cgl_context,
       is_vsync_disabled,
+      display_link,
       shader_program_cache.Pass());
 }
 
@@ -112,6 +119,7 @@ CompositingIOSurfaceContext::CompositingIOSurfaceContext(
     NSOpenGLContext* nsgl_context,
     CGLContextObj cgl_context,
     bool is_vsync_disabled,
+    scoped_refptr<DisplayLinkMac> display_link,
     scoped_ptr<CompositingIOSurfaceShaderPrograms> shader_program_cache)
     : window_number_(window_number),
       nsgl_context_(nsgl_context),
@@ -121,7 +129,8 @@ CompositingIOSurfaceContext::CompositingIOSurfaceContext(
       can_be_shared_(true),
       initialized_is_intel_(false),
       is_intel_(false),
-      screen_(0) {
+      screen_(0),
+      display_link_(display_link) {
   DCHECK(window_map()->find(window_number_) == window_map()->end());
   window_map()->insert(std::make_pair(window_number_, this));
 }
diff --git a/content/browser/renderer_host/compositing_iosurface_layer_mac.mm b/content/browser/renderer_host/compositing_iosurface_layer_mac.mm
index 068e40b..7417e29 100644
--- a/content/browser/renderer_host/compositing_iosurface_layer_mac.mm
+++ b/content/browser/renderer_host/compositing_iosurface_layer_mac.mm
@@ -79,23 +79,30 @@
       &attribs.front(), &pixel_format, &number_virtual_screens);
   if (error != kCGLNoError) {
     LOG(ERROR) << "Failed to create pixel format for layer.";
+    CHECK(0);
     return nil;
   }
   return pixel_format;
 }
 
 - (void)releaseCGLPixelFormat:(CGLPixelFormatObj)pixelFormat {
+  if (!pixelFormat) {
+    CHECK(0);
+  }
+
   CGLReleasePixelFormat(pixelFormat);
 }
 
 - (CGLContextObj)copyCGLContextForPixelFormat:(CGLPixelFormatObj)pixelFormat {
   if (!renderWidgetHostView_) {
+    CHECK(0);
     LOG(ERROR) << "Cannot create layer context because there is no host.";
     return nil;
   }
 
   context_ = renderWidgetHostView_->compositing_iosurface_context_;
   if (!context_) {
+    CHECK(0);
     LOG(ERROR) << "Cannot create layer context because host has no context.";
     return nil;
   }
@@ -104,8 +111,10 @@
 }
 
 - (void)releaseCGLContext:(CGLContextObj)glContext {
-  if (!context_.get())
+  if (!context_) {
+    CHECK(0);
     return;
+  }
 
   DCHECK(glContext == context_->cgl_context());
   context_ = nil;
diff --git a/content/browser/renderer_host/compositing_iosurface_mac.h b/content/browser/renderer_host/compositing_iosurface_mac.h
index 87d8cc6..18795af 100644
--- a/content/browser/renderer_host/compositing_iosurface_mac.h
+++ b/content/browser/renderer_host/compositing_iosurface_mac.h
@@ -9,13 +9,11 @@
 #include <vector>
 
 #import <Cocoa/Cocoa.h>
-#import <QuartzCore/CVDisplayLink.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/callback.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "media/base/video_frame.h"
@@ -100,24 +98,10 @@ class CompositingIOSurfaceMac {
   const gfx::Size& dip_io_surface_size() const { return dip_io_surface_size_; }
   float scale_factor() const { return scale_factor_; }
 
-  // Get vsync scheduling parameters.
-  // |interval_numerator/interval_denominator| equates to fractional number of
-  // seconds between vsyncs.
-  void GetVSyncParameters(base::TimeTicks* timebase,
-                          uint32* interval_numerator,
-                          uint32* interval_denominator);
-
   // Returns true if asynchronous readback is supported on this system.
   bool IsAsynchronousReadbackSupported();
 
  private:
-  friend CVReturn DisplayLinkCallback(CVDisplayLinkRef,
-                                      const CVTimeStamp*,
-                                      const CVTimeStamp*,
-                                      CVOptionFlags,
-                                      CVOptionFlags*,
-                                      void*);
-
   // Vertex structure for use in glDraw calls.
   struct SurfaceVertex {
     SurfaceVertex() : x_(0.0f), y_(0.0f), tx_(0.0f), ty_(0.0f) { }
@@ -209,8 +193,6 @@ class CompositingIOSurfaceMac {
       IOSurfaceSupport* io_surface_support,
       const scoped_refptr<CompositingIOSurfaceContext>& context);
 
-  void SetupCVDisplayLink();
-
   // If this IOSurface has moved to a different window, use that window's
   // GL context (if multiple visible windows are using the same GL context
   // then call to setView call can stall and prevent reaching 60fps).
@@ -228,19 +210,6 @@ class CompositingIOSurfaceMac {
 
   void DrawQuad(const SurfaceQuad& quad);
 
-  // Called on display-link thread.
-  void DisplayLinkTick(CVDisplayLinkRef display_link,
-                       const CVTimeStamp* time);
-
-  void CalculateVsyncParametersLockHeld(const CVTimeStamp* time);
-
-  // Prevent from spinning on CGLFlushDrawable when it fails to throttle to
-  // VSync frequency.
-  void RateLimitDraws();
-
-  void StartOrContinueDisplayLink();
-  void StopDisplayLink();
-
   // Copy current frame to |target| video frame. This method must be called
   // within a CGL context. Returns a callback that should be called outside
   // of the CGL context.
@@ -327,20 +296,6 @@ class CompositingIOSurfaceMac {
   // Timer for finishing a copy operation.
   base::Timer finish_copy_timer_;
 
-  // CVDisplayLink for querying Vsync timing info and throttling swaps.
-  CVDisplayLinkRef display_link_;
-
-  // Timer for stopping display link after a timeout with no swaps.
-  base::DelayTimer<CompositingIOSurfaceMac> display_link_stop_timer_;
-
-  // Lock for sharing data between UI thread and display-link thread.
-  base::Lock lock_;
-
-  // Vsync timing data.
-  base::TimeTicks vsync_timebase_;
-  uint32 vsync_interval_numerator_;
-  uint32 vsync_interval_denominator_;
-
   // Error saved by GetAndSaveGLError
   GLint gl_error_;
 };
diff --git a/content/browser/renderer_host/compositing_iosurface_mac.mm b/content/browser/renderer_host/compositing_iosurface_mac.mm
index f356bd0..41ed130 100644
--- a/content/browser/renderer_host/compositing_iosurface_mac.mm
+++ b/content/browser/renderer_host/compositing_iosurface_mac.mm
@@ -156,18 +156,6 @@ bool MapBufferToVideoFrame(
 
 }  // namespace
 
-CVReturn DisplayLinkCallback(CVDisplayLinkRef display_link,
-                             const CVTimeStamp* now,
-                             const CVTimeStamp* output_time,
-                             CVOptionFlags flags_in,
-                             CVOptionFlags* flags_out,
-                             void* context) {
-  CompositingIOSurfaceMac* surface =
-      static_cast<CompositingIOSurfaceMac*>(context);
-  surface->DisplayLinkTick(display_link, output_time);
-  return kCVReturnSuccess;
-}
-
 CompositingIOSurfaceMac::CopyContext::CopyContext(
     const scoped_refptr<CompositingIOSurfaceContext>& context)
   : transformer(new CompositingIOSurfaceTransformer(
@@ -263,63 +251,12 @@ CompositingIOSurfaceMac::CompositingIOSurfaceMac(
                      base::Unretained(this),
                      false),
           true),
-      display_link_(0),
-      display_link_stop_timer_(FROM_HERE, base::TimeDelta::FromSeconds(1),
-                               this, &CompositingIOSurfaceMac::StopDisplayLink),
-      vsync_interval_numerator_(0),
-      vsync_interval_denominator_(0),
       gl_error_(GL_NO_ERROR) {
   CHECK(offscreen_context_);
 }
 
-void CompositingIOSurfaceMac::SetupCVDisplayLink() {
-  if (display_link_) {
-    LOG(ERROR) << "DisplayLink already setup";
-    return;
-  }
-
-  CVDisplayLinkRef display_link;
-  CVReturn ret = CVDisplayLinkCreateWithActiveCGDisplays(&display_link);
-  if (ret != kCVReturnSuccess) {
-    LOG(WARNING) << "CVDisplayLinkCreateWithActiveCGDisplays failed: " << ret;
-    return;
-  }
-
-  display_link_ = display_link;
-
-  ret = CVDisplayLinkSetOutputCallback(display_link_,
-                                       &DisplayLinkCallback, this);
-  DCHECK(ret == kCVReturnSuccess)
-      << "CVDisplayLinkSetOutputCallback failed: " << ret;
-
-  StartOrContinueDisplayLink();
-
-  CVTimeStamp cv_time;
-  ret = CVDisplayLinkGetCurrentTime(display_link_, &cv_time);
-  DCHECK(ret == kCVReturnSuccess)
-      << "CVDisplayLinkGetCurrentTime failed: " << ret;
-
-  {
-    base::AutoLock lock(lock_);
-    CalculateVsyncParametersLockHeld(&cv_time);
-  }
-
-  // Stop display link for now, it will be started when needed during Draw.
-  StopDisplayLink();
-}
-
-void CompositingIOSurfaceMac::GetVSyncParameters(base::TimeTicks* timebase,
-                                                 uint32* interval_numerator,
-                                                 uint32* interval_denominator) {
-  base::AutoLock lock(lock_);
-  *timebase = vsync_timebase_;
-  *interval_numerator = vsync_interval_numerator_;
-  *interval_denominator = vsync_interval_denominator_;
-}
-
 CompositingIOSurfaceMac::~CompositingIOSurfaceMac() {
   FailAllCopies();
-  CVDisplayLinkRelease(display_link_);
   CGLSetCurrentContext(offscreen_context_->cgl_context());
   DestroyAllCopyContextsWithinContext();
   UnrefIOSurfaceWithContextCurrent();
@@ -357,9 +294,6 @@ bool CompositingIOSurfaceMac::DrawIOSurface(
     bool flush_drawable) {
   DCHECK_EQ(CGLGetCurrentContext(), drawing_context->cgl_context());
 
-  if (display_link_ == NULL)
-    SetupCVDisplayLink();
-
   bool has_io_surface = HasIOSurface();
   TRACE_EVENT1("browser", "CompositingIOSurfaceMac::DrawIOSurface",
                "has_io_surface", has_io_surface);
@@ -487,8 +421,6 @@ bool CompositingIOSurfaceMac::DrawIOSurface(
   // Try to finish previous copy requests after flush to get better pipelining.
   CheckIfAllCopiesAreFinished(false);
 
-  StartOrContinueDisplayLink();
-
   return result;
 }
 
@@ -646,43 +578,6 @@ void CompositingIOSurfaceMac::UnrefIOSurfaceWithContextCurrent() {
   io_surface_handle_ = 0;
 }
 
-void CompositingIOSurfaceMac::DisplayLinkTick(CVDisplayLinkRef display_link,
-                                              const CVTimeStamp* time) {
-  TRACE_EVENT0("gpu", "CompositingIOSurfaceMac::DisplayLinkTick");
-  base::AutoLock lock(lock_);
-  CalculateVsyncParametersLockHeld(time);
-}
-
-void CompositingIOSurfaceMac::CalculateVsyncParametersLockHeld(
-    const CVTimeStamp* time) {
-  lock_.AssertAcquired();
-  vsync_interval_numerator_ = static_cast<uint32>(time->videoRefreshPeriod);
-  vsync_interval_denominator_ = time->videoTimeScale;
-  // Verify that videoRefreshPeriod is 32 bits.
-  DCHECK((time->videoRefreshPeriod & ~0xffffFFFFull) == 0ull);
-
-  vsync_timebase_ =
-      base::TimeTicks::FromInternalValue(time->hostTime / 1000);
-}
-
-void CompositingIOSurfaceMac::StartOrContinueDisplayLink() {
-  if (display_link_ == NULL)
-    return;
-
-  if (!CVDisplayLinkIsRunning(display_link_)) {
-    CVDisplayLinkStart(display_link_);
-  }
-  display_link_stop_timer_.Reset();
-}
-
-void CompositingIOSurfaceMac::StopDisplayLink() {
-  if (display_link_ == NULL)
-    return;
-
-  if (CVDisplayLinkIsRunning(display_link_))
-    CVDisplayLinkStop(display_link_);
-}
-
 bool CompositingIOSurfaceMac::IsAsynchronousReadbackSupported() {
   const bool forced_synchronous = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kForceSynchronousGLReadPixels);
diff --git a/content/browser/renderer_host/display_link_mac.cc b/content/browser/renderer_host/display_link_mac.cc
new file mode 100644
index 0000000..843eb1a
--- /dev/null
+++ b/content/browser/renderer_host/display_link_mac.cc
@@ -0,0 +1,124 @@
+// 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/display_link_mac.h"
+
+#include "base/debug/trace_event.h"
+#include "base/logging.h"
+
+namespace content {
+
+// static
+scoped_refptr<DisplayLinkMac> DisplayLinkMac::Create() {
+  CVReturn ret = kCVReturnSuccess;
+
+  scoped_refptr<DisplayLinkMac> display_link_mac;
+  {
+    CVDisplayLinkRef display_link = NULL;
+    ret = CVDisplayLinkCreateWithActiveCGDisplays(&display_link);
+    if (ret != kCVReturnSuccess) {
+      LOG(ERROR) << "CVDisplayLinkCreateWithActiveCGDisplays failed: " << ret;
+      return NULL;
+    }
+    display_link_mac = new DisplayLinkMac(display_link);
+  }
+
+  ret = CVDisplayLinkSetOutputCallback(
+      display_link_mac->display_link_,
+      &DisplayLinkCallback,
+      display_link_mac.get());
+  if (ret != kCVReturnSuccess) {
+    LOG(ERROR) << "CVDisplayLinkSetOutputCallback failed: " << ret;
+    return NULL;
+  }
+
+  return display_link_mac;
+}
+
+DisplayLinkMac::DisplayLinkMac(CVDisplayLinkRef display_link)
+  : display_link_(display_link),
+    stop_timer_(
+        FROM_HERE, base::TimeDelta::FromSeconds(1),
+        this, &DisplayLinkMac::StopDisplayLink),
+    timebase_and_interval_valid_(false) {
+}
+
+DisplayLinkMac::~DisplayLinkMac() {
+  if (CVDisplayLinkIsRunning(display_link_))
+    CVDisplayLinkStop(display_link_);
+}
+
+bool DisplayLinkMac::GetVSyncParameters(
+    base::TimeTicks* timebase, base::TimeDelta* interval) {
+  StartOrContinueDisplayLink();
+
+  base::AutoLock lock(lock_);
+  if (!timebase_and_interval_valid_)
+    return false;
+
+  *timebase = timebase_;
+  *interval = interval_;
+  return true;
+}
+
+void DisplayLinkMac::Tick(const CVTimeStamp* cv_time) {
+  TRACE_EVENT0("browser", "DisplayLinkMac::GetVSyncParameters");
+  base::AutoLock lock(lock_);
+
+  // Verify that videoRefreshPeriod is 32 bits.
+  DCHECK((cv_time->videoRefreshPeriod & ~0xffffFFFFull) == 0ull);
+
+  // Verify that the numerator and denominator make some sense.
+  uint32 numerator = static_cast<uint32>(cv_time->videoRefreshPeriod);
+  uint32 denominator = cv_time->videoTimeScale;
+  if (numerator <= 0 || denominator <= 0) {
+    LOG(WARNING) << "Unexpected numerator or denominator, bailing.";
+    return;
+  }
+
+  timebase_ = base::TimeTicks::FromInternalValue(
+      cv_time->hostTime / 1000);
+  interval_ = base::TimeDelta::FromMicroseconds(
+      1000000 * static_cast<int64>(numerator) / denominator);
+  timebase_and_interval_valid_ = true;
+}
+
+void DisplayLinkMac::StartOrContinueDisplayLink() {
+  // Reset the timer, so that the display link won't be turned off for another
+  // second.
+  stop_timer_.Reset();
+
+  if (CVDisplayLinkIsRunning(display_link_))
+    return;
+
+  CVReturn ret = CVDisplayLinkStart(display_link_);
+  if (ret != kCVReturnSuccess) {
+    LOG(ERROR) << "CVDisplayLinkStart failed: " << ret;
+  }
+}
+
+void DisplayLinkMac::StopDisplayLink() {
+  if (!CVDisplayLinkIsRunning(display_link_))
+    return;
+
+  CVReturn ret = CVDisplayLinkStop(display_link_);
+  if (ret != kCVReturnSuccess) {
+    LOG(ERROR) << "CVDisplayLinkStop failed: " << ret;
+  }
+}
+
+CVReturn DisplayLinkMac::DisplayLinkCallback(
+    CVDisplayLinkRef display_link,
+    const CVTimeStamp* now,
+    const CVTimeStamp* output_time,
+    CVOptionFlags flags_in,
+    CVOptionFlags* flags_out,
+    void* context) {
+  DisplayLinkMac* display_link_mac = static_cast<DisplayLinkMac*>(context);
+  display_link_mac->Tick(output_time);
+  return kCVReturnSuccess;
+}
+
+}  // content
+
diff --git a/content/browser/renderer_host/display_link_mac.h b/content/browser/renderer_host/display_link_mac.h
new file mode 100644
index 0000000..35a28ef2
--- /dev/null
+++ b/content/browser/renderer_host/display_link_mac.h
@@ -0,0 +1,63 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_DISPLAY_LINK_MAC_H_
+#define CONTENT_BROWSER_RENDERER_HOST_DISPLAY_LINK_MAC_H_
+
+#import <QuartzCore/CVDisplayLink.h>
+
+#include "base/mac/scoped_cftyperef.h"
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+
+namespace content {
+
+class DisplayLinkMac : public base::RefCounted<DisplayLinkMac> {
+ public:
+  static scoped_refptr<DisplayLinkMac> Create();
+
+  // Get vsync scheduling parameters.
+  bool GetVSyncParameters(
+      base::TimeTicks* timebase,
+      base::TimeDelta* interval);
+
+ private:
+  friend class base::RefCounted<DisplayLinkMac>;
+
+  DisplayLinkMac(CVDisplayLinkRef display_link);
+  virtual ~DisplayLinkMac();
+
+  void StartOrContinueDisplayLink();
+  void StopDisplayLink();
+  void Tick(const CVTimeStamp* time);
+
+  static CVReturn DisplayLinkCallback(
+      CVDisplayLinkRef display_link,
+      const CVTimeStamp* now,
+      const CVTimeStamp* output_time,
+      CVOptionFlags flags_in,
+      CVOptionFlags* flags_out,
+      void* context);
+
+  // CVDisplayLink for querying VSync timing info.
+  base::ScopedCFTypeRef<CVDisplayLinkRef> display_link_;
+
+  // Timer for stopping the display link if it has not been queried in
+  // the last second.
+  base::DelayTimer<DisplayLinkMac> stop_timer_;
+
+  // VSync parameters computed during Tick.
+  bool timebase_and_interval_valid_;
+  base::TimeTicks timebase_;
+  base::TimeDelta interval_;
+
+  // Lock for sharing data between UI thread and display-link thread.
+  base::Lock lock_;
+};
+
+}  // content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_DISPLAY_LINK_MAC_H_
diff --git a/content/browser/renderer_host/render_widget_host_view_mac.mm b/content/browser/renderer_host/render_widget_host_view_mac.mm
index 521d97f..76ed055 100644
--- a/content/browser/renderer_host/render_widget_host_view_mac.mm
+++ b/content/browser/renderer_host/render_widget_host_view_mac.mm
@@ -1859,6 +1859,15 @@ void RenderWidgetHostViewMac::ShutdownHost() {
 }
 
 void RenderWidgetHostViewMac::GotAcceleratedFrame() {
+  // Update the host with VSync parametrs.
+  base::TimeTicks timebase;
+  base::TimeDelta interval;
+  if (compositing_iosurface_context_ &&
+      compositing_iosurface_context_->display_link()->GetVSyncParameters(
+          &timebase, &interval)) {
+    render_widget_host_->UpdateVSyncParameters(timebase, interval);
+  }
+
   // Update the scale factor of the layer to match the scale factor of the
   // IOSurface.
   [compositing_iosurface_layer_ updateScaleFactor];
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index c8be4de..76cc65d 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -828,6 +828,8 @@
     'browser/renderer_host/delegated_frame_evictor.h',
     'browser/renderer_host/dip_util.cc',
     'browser/renderer_host/dip_util.h',
+    'browser/renderer_host/display_link_mac.h',
+    'browser/renderer_host/display_link_mac.cc',
     'browser/renderer_host/file_utilities_message_filter.cc',
     'browser/renderer_host/file_utilities_message_filter.h',
     'browser/renderer_host/gamepad_browser_message_filter.cc',
diff --git a/content/gpu/gpu_main.cc b/content/gpu/gpu_main.cc
index 9e6160d..713b337 100644
--- a/content/gpu/gpu_main.cc
+++ b/content/gpu/gpu_main.cc
@@ -222,9 +222,11 @@ int GpuMain(const MainFunctionParams& parameters) {
     // Determine if we need to initialize GL here or it has already been done.
     bool gl_already_initialized = false;
 #if defined(OS_MACOSX)
-    // On Mac, GLSurface::InitializeOneOff() is called from the sandbox warmup
-    // code before getting here.
-    gl_already_initialized = true;
+    if (!command_line.HasSwitch(switches::kNoSandbox)) {
+      // On Mac, if the sandbox is enabled, then GLSurface::InitializeOneOff()
+      // is called from the sandbox warmup code before getting here.
+      gl_already_initialized = true;
+    }
 #endif
     if (command_line.HasSwitch(switches::kInProcessGPU)) {
       // With in-process GPU, GLSurface::InitializeOneOff() is called from