[Remoting Android] Fix thread issue with OpenGL drawable

remoting/client/display/gl_cursor.cc

 // Copyright 2016 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 "remoting/client/display/gl_cursor.h"
 
 #include "remoting/base/util.h"
 #include "remoting/client/display/gl_canvas.h"
 #include "remoting/client/display/gl_math.h"
 #include "remoting/client/display/gl_render_layer.h"
 #include "remoting/client/display/gl_texture_ids.h"
 #include "remoting/proto/control.pb.h"
 #include "third_party/libyuv/include/libyuv/convert_argb.h"
 
 namespace remoting {
 
 namespace {
 const int kDefaultCursorDataSize = 32 * 32 * GlRenderLayer::kBytesPerPixel;
 }  // namespace
 
-GlCursor::GlCursor() : weak_factory_(this) {}
+GlCursor::GlCursor() : weak_factory_(this) {
+  weak_ptr_ = weak_factory_.GetWeakPtr();

[Sergey Ulanov, 2017/01/13 02:03:10]

With the current implementation of WeakFactory to make GetWeakPtr() safe you
just need to call GetWeakPtr() here, but don't need to keep the result. But see
my next comment.

+}
 
 GlCursor::~GlCursor() {}
 
 void GlCursor::SetCursorShape(const protocol::CursorShapeInfo& cursor_shape) {
   int data_size = cursor_shape.width() * cursor_shape.height() *
                   GlRenderLayer::kBytesPerPixel;
   if (current_cursor_data_size_ < data_size) {
     current_cursor_data_size_ =
         kDefaultCursorDataSize > data_size ? kDefaultCursorDataSize : data_size;
     current_cursor_data_.reset(new uint8_t[current_cursor_data_size_]);
@@ skipping 42 matching lines @@
     return;
   }
   layer_.reset(new GlRenderLayer(kGlCursorTextureId, canvas));
   if (current_cursor_data_) {
     SetCurrentCursorShape(true);
   }
   SetCursorPosition(cursor_x_, cursor_y_);
 }
 
 bool GlCursor::Draw() {
-  DCHECK(thread_checker_.CalledOnValidThread());
   if (layer_ && current_cursor_data_ && visible_) {
     layer_->Draw(1.f);
   }
   return false;
 }
 
 int GlCursor::GetZIndex() {
   return Drawable::ZIndex::CURSOR;
 }
 
 void GlCursor::SetCurrentCursorShape(bool size_changed) {
   if (layer_) {
     if (size_changed) {
       layer_->SetTexture(current_cursor_data_.get(), current_cursor_width_,
                          current_cursor_height_, 0);
     } else {
       layer_->UpdateTexture(current_cursor_data_.get(), 0, 0,
                             current_cursor_width_, current_cursor_width_, 0);
     }
   }
 }
 
 base::WeakPtr<Drawable> GlCursor::GetWeakPtr() {

[Sergey Ulanov, 2017/01/13 02:03:10]

Does this function really need to be thread-safe? The renderer overall should be
single-threaded, so I don't see any case when it can be useful to call this
function on any thread other than the one where it's created.

[nicholss, 2017/01/13 16:45:00]

I think in the future it will be accessed via many threads potentially. 

-  DCHECK(thread_checker_.CalledOnValidThread());
-  return weak_factory_.GetWeakPtr();
+  return weak_ptr_;
 }
 
 }  // namespace remoting