Update from https://crrev.com/320931

ui/gl/gl_context.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 <string>
 
+#include "base/bind.h"
+#include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/thread_local.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
@@ skipping 17 matching lines @@
     GetCurrent()->ReleaseCurrent(NULL);
   }
 }
 
 void GLContext::ScopedReleaseCurrent::Cancel() {
   canceled_ = true;
 }
 
 GLContext::GLContext(GLShareGroup* share_group) :
     share_group_(share_group),
+    state_dirtied_externally_(false),
     swap_interval_(1),
-    force_swap_interval_zero_(false) {
+    force_swap_interval_zero_(false),
+    state_dirtied_callback_(
+        base::Bind(&GLContext::SetStateWasDirtiedExternally,
+        // Note that if this is not unretained, it will create a cycle (and
+        // will never be freed.
+        base::Unretained(this),
+        true)) {
   if (!share_group_.get())
     share_group_ = new GLShareGroup;
 
   share_group_->AddContext(this);
 }
 
 GLContext::~GLContext() {
   share_group_->RemoveContext(this);
   if (GetCurrent() == this) {
     SetCurrent(NULL);
@@ skipping 30 matching lines @@
   return std::string(version ? version : "");
 }
 
 std::string GLContext::GetGLRenderer() {
   DCHECK(IsCurrent(NULL));
   const char *renderer =
       reinterpret_cast<const char*>(glGetString(GL_RENDERER));
   return std::string(renderer ? renderer : "");
 }
 
+base::Closure GLContext::GetStateWasDirtiedExternallyCallback() {
+  return state_dirtied_callback_.callback();
+}
+
+void GLContext::RestoreStateIfDirtiedExternally() {
+  NOTREACHED();
+}
+
+bool GLContext::GetStateWasDirtiedExternally() const {
+  DCHECK(virtual_gl_api_);
+  return state_dirtied_externally_;
+}
+
+void GLContext::SetStateWasDirtiedExternally(bool dirtied_externally) {
+  DCHECK(virtual_gl_api_);
+  state_dirtied_externally_ = dirtied_externally;
+}
+
 bool GLContext::HasExtension(const char* name) {
   std::string extensions = GetExtensions();
   extensions += " ";
 
   std::string delimited_name(name);
   delimited_name += " ";
 
   return extensions.find(delimited_name) != std::string::npos;
 }
 
@@ skipping 115 matching lines @@
 }
 
 GLContextReal::~GLContextReal() {}
 
 void GLContextReal::SetCurrent(GLSurface* surface) {
   GLContext::SetCurrent(surface);
   current_real_context_.Pointer()->Set(surface ? this : NULL);
 }
 
 }  // namespace gfx