Make Reflector Use Main Thread MessageLoop when in SingleThread

content/browser/compositor/reflector_impl_unittest.cc

 // Copyright 2015 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 "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_web_graphics_context_3d.h"
@@ skipping 76 matching lines @@
         cc::TestWebGraphicsContext3D::Create().Pass());
     output_surface_ =
         scoped_ptr<TestOutputSurface>(
             new TestOutputSurface(context_provider_, 1, &surface_map_,
                                   compositor_->vsync_manager())).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     mirroring_layer_.reset(new ui::Layer());
     gfx::Size size = output_surface_->SurfaceSize();
     mirroring_layer_->SetBounds(gfx::Rect(size.width(), size.height()));
+  }
 
+  void SetUpReflector(bool threaded) {
     int32 surface_id = 1;
-    reflector_ = new ReflectorImpl(compositor_.get(), mirroring_layer_.get(),
-                                   &surface_map_, proxy_.get(), surface_id);
+
+    if (threaded) {
+      reflector_ = new ReflectorImpl(compositor_.get(), mirroring_layer_.get(),
+                                     &surface_map_, proxy_.get(), surface_id);
+    } else {
+      reflector_ = new ReflectorImpl(compositor_.get(), mirroring_layer_.get(),
+                                     &surface_map_, NULL, surface_id);
+    }
   }
 
   void TearDown() override {
     cc::TextureMailbox mailbox;
     scoped_ptr<cc::SingleReleaseCallback> release;
     if (mirroring_layer_->PrepareTextureMailbox(&mailbox, &release, false)) {
       release->Run(0, false);
     }
     compositor_.reset();
     ui::TerminateContextFactoryForTests();
@@ skipping 15 matching lines @@
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_refptr<base::MessageLoopProxy> proxy_;
   scoped_ptr<ui::Compositor> compositor_;
   scoped_ptr<ui::Layer> mirroring_layer_;
   scoped_refptr<ReflectorImpl> reflector_;
   scoped_ptr<TestOutputSurface> output_surface_;
 };
 
 namespace {
 TEST_F(ReflectorImplTest, CheckNormalOutputSurface) {
+  bool threaded = true;
+  SetUpReflector(threaded);
   output_surface_->SetFlip(false);
   Init();
   UpdateTexture();
   EXPECT_TRUE(mirroring_layer_->TextureFlipped());
   EXPECT_EQ(SkRegion(SkIRect::MakeXYWH(
                 0, output_surface_->SurfaceSize().height() - kSubRect.height(),
                 kSubRect.width(), kSubRect.height())),
             mirroring_layer_->damaged_region());
 }
 
 TEST_F(ReflectorImplTest, CheckInvertedOutputSurface) {
+  bool threaded = true;
+  SetUpReflector(threaded);
   output_surface_->SetFlip(true);
   Init();
   UpdateTexture();
+  EXPECT_FALSE(mirroring_layer_->TextureFlipped());
+  EXPECT_EQ(SkRegion(kSkSubRect), mirroring_layer_->damaged_region());
+}
+
+TEST_F(ReflectorImplTest, CheckNormalOutputSurface_SingleThread) {
+  bool threaded = false;
+  SetUpReflector(threaded);
+  output_surface_->SetFlip(false);
+  Init();
+  UpdateTexture();
+  EXPECT_TRUE(mirroring_layer_->TextureFlipped());
+  EXPECT_EQ(SkRegion(SkIRect::MakeXYWH(
+                0, output_surface_->SurfaceSize().height() - kSubRect.height(),
+                kSubRect.width(), kSubRect.height())),
+            mirroring_layer_->damaged_region());
+}
+
+TEST_F(ReflectorImplTest, CheckInvertedOutputSurface_SingleThread) {
+  bool threaded = false;
+  SetUpReflector(threaded);
+  output_surface_->SetFlip(true);
+  Init();
+  UpdateTexture();
   EXPECT_FALSE(mirroring_layer_->TextureFlipped());
   EXPECT_EQ(SkRegion(kSkSubRect), mirroring_layer_->damaged_region());
 }
 
 }  // namespace
 }  // namespace content