Fix build error in release mode.

content/renderer/gpu/renderer_gl_context.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/renderer/gpu/renderer_gl_context.h"
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
-#include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/gpu/transport_texture_host.h"
 #include "content/renderer/gpu/transport_texture_service.h"
 #include "content/renderer/render_thread.h"
 #include "content/renderer/render_widget.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_channel_handle.h"
@@ skipping 169 matching lines @@
   gles2_implementation_->DeleteTextures(1, &texture);
 }
 
 void RendererGLContext::SetContextLostCallback(
     Callback1<ContextLostReason>::Type* callback) {
   context_lost_callback_.reset(callback);
 }
 
 bool RendererGLContext::MakeCurrent(RendererGLContext* context) {
   if (context) {
-    DCHECK(MessageLoop::current() == context->message_loop_);
+    DCHECK(context->CalledOnValidThread());
     gles2::SetGLContext(context->gles2_implementation_);
 
     // Don't request latest error status from service. Just use the locally
     // cached information from the last flush.
     // TODO(apatrick): I'm not sure if this should actually change the
     // current context if it fails. For now it gets changed even if it fails
     // because making GL calls with a NULL context crashes.
     if (context->command_buffer_->GetLastState().error != gpu::error::kNoError)
       return false;
   } else {
@@ skipping 60 matching lines @@
 
 RendererGLContext::RendererGLContext(GpuChannelHost* channel)
     : channel_(channel),
       parent_(base::WeakPtr<RendererGLContext>()),
       parent_texture_id_(0),
       command_buffer_(NULL),
       gles2_helper_(NULL),
       transfer_buffer_id_(-1),
       gles2_implementation_(NULL),
       last_error_(SUCCESS),
-      frame_number_(0)
-#ifndef NDEBUG
-      , message_loop_(MessageLoop::current())
-#endif
-{
+      frame_number_(0) {
   DCHECK(channel);
 }
 
 bool RendererGLContext::Initialize(bool onscreen,
                                    int render_view_id,
                                    const gfx::Size& size,
                                    RendererGLContext* share_group,
                                    const char* allowed_extensions,
                                    const int32* attrib_list,
                                    const GURL& active_url) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(CalledOnValidThread());
   DCHECK(size.width() >= 0 && size.height() >= 0);
   TRACE_EVENT2("gpu", "RendererGLContext::Initialize",
                    "on_screen", onscreen, "num_pixels", size.GetArea());
 
   if (channel_->state() != GpuChannelHost::kConnected)
     return false;
 
   // Ensure the gles2 library is initialized first in a thread safe way.
   g_gles2_initializer.Get();
 
@@ skipping 103 matching lines @@
       transfer_buffer.ptr,
       transfer_buffer_id_,
       share_resources,
       bind_generates_resources);
 
   return true;
 }
 
 void RendererGLContext::Destroy() {
   TRACE_EVENT0("gpu", "RendererGLContext::Destroy");
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(CalledOnValidThread());
   SetParent(NULL);
 
   if (gles2_implementation_) {
     // First flush the context to ensure that any pending frees of resources
     // are completed. Otherwise, if this context is part of a share group,
     // those resources might leak. Also, any remaining side effects of commands
     // issued on this context might not be visible to other contexts in the
     // share group.
     gles2_implementation_->Flush();
 
@@ skipping 20 matching lines @@
 void RendererGLContext::OnContextLost() {
   if (context_lost_callback_.get()) {
     RendererGLContext::ContextLostReason reason = kUnknown;
     if (command_buffer_) {
       reason = ConvertReason(
           command_buffer_->GetLastState().context_lost_reason);
     }
     context_lost_callback_->Run(reason);
   }
 }