Revert 216780 "Clean up compositor initialization/destruction."

trunk/src/content/browser/renderer_host/render_widget_host_view_browsertest.cc

 // Copyright (c) 2013 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/command_line.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/renderer_host/dip_util.h"
@@ skipping 10 matching lines @@
 #include "content/shell/shell.h"
 #include "content/test/content_browser_test.h"
 #include "content/test/content_browser_test_utils.h"
 #include "media/base/video_frame.h"
 #include "media/filters/skcanvas_video_renderer.h"
 #include "net/base/net_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "ui/base/ui_base_switches.h"
+#include "ui/compositor/compositor_setup.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_MACOSX)
 #include "ui/gl/io_surface_support_mac.h"
 #endif
 
 #if defined(OS_WIN)
 #include "ui/base/win/dpi.h"
 #endif
@@ skipping 163 matching lines @@
  private:
   const gfx::Size frame_size_;
   base::FilePath test_dir_;
   int callback_invoke_count_;
   int frames_captured_;
 };
 
 class CompositingRenderWidgetHostViewBrowserTest
     : public RenderWidgetHostViewBrowserTest {
  public:
-  virtual void SetUp() OVERRIDE {
-    // We expect real pixel output for these tests.
-    UseRealGLContexts();
-
-    // On legacy windows, these tests need real GL bindings to pass.
-#if defined(OS_WIN) && !defined(USE_AURA)
-    UseRealGLBindings();
-#endif
-
-    RenderWidgetHostViewBrowserTest::SetUp();
-  }
-
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Note: Not appending kForceCompositingMode switch here, since not all bots
     // support compositing.  Some bots will run with compositing on, and others
     // won't.  Therefore, the call to SetUpSourceSurface() later on will detect
     // whether compositing mode is actually on or not.  If not, the tests will
     // pass blindly, logging a warning message, since we cannot test what the
     // platform/implementation does not support.
     RenderWidgetHostViewBrowserTest::SetUpCommandLine(command_line);
   }
 
@@ skipping 98 matching lines @@
 };
 
 // Disable tests for Android and IOS as these platforms have incomplete
 // implementation.
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 
 // The CopyFromBackingStore() API should work on all platforms when compositing
 // is enabled.
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
                        CopyFromBackingStore) {
+#if defined(USE_AURA)
+  if (ui::IsTestCompositorEnabled()) {
+    LOG(WARNING) << ("Blindly passing this test: Aura test compositor doesn't "
+                     "support copying from backing store.");
+    // TODO(jbauman): Aura test compositor should support copying from backing
+    // store. http://crbug.com/268644
+    return;
+  }
+#endif
   RunBasicCopyFromBackingStoreTest();
 }
 
 // The CopyFromBackingStore() API should work on all platforms when compositing
 // is disabled.
 IN_PROC_BROWSER_TEST_F(NonCompositingRenderWidgetHostViewBrowserTest,
                        CopyFromBackingStore) {
   RunBasicCopyFromBackingStoreTest();
 }
 
@@ skipping 22 matching lines @@
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
                        CopyFromCompositingSurface_CallbackDespiteDelete) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   if (!view->CanCopyToVideoFrame()) {
     LOG(WARNING) <<
         ("Blindly passing this test: CopyFromCompositingSurfaceToVideoFrame() "
          "not supported on this platform.");
     return;
   }
-
   base::RunLoop run_loop;
   scoped_refptr<media::VideoFrame> dest =
       media::VideoFrame::CreateBlackFrame(frame_size());
   view->CopyFromCompositingSurfaceToVideoFrame(
       gfx::Rect(view->GetViewBounds().size()), dest, base::Bind(
           &RenderWidgetHostViewBrowserTest::FinishCopyFromCompositingSurface,
           base::Unretained(this), run_loop.QuitClosure()));
   // Delete the surface before the callback is run.
   view->AcceleratedSurfaceRelease();
   run_loop.Run();
@@ skipping 13 matching lines @@
 // until at least one DeliverFrameCallback has been invoked.
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
                        FrameSubscriberTest) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   if (!view->CanSubscribeFrame()) {
     LOG(WARNING) << ("Blindly passing this test: Frame subscription not "
                      "supported on this platform.");
     return;
   }
+#if defined(USE_AURA)
+  if (ui::IsTestCompositorEnabled()) {
+    LOG(WARNING) << ("Blindly passing this test: Aura test compositor doesn't "
+                     "support frame subscription.");
+    // TODO(miu): Aura test compositor should support frame subscription for
+    // testing.  http://crbug.com/240572
+    return;
+  }
+#endif
 
   base::RunLoop run_loop;
   scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
       new FakeFrameSubscriber(
           base::Bind(&RenderWidgetHostViewBrowserTest::FrameDelivered,
                      base::Unretained(this),
                      base::MessageLoopProxy::current(),
                      run_loop.QuitClosure())));
   view->BeginFrameSubscription(subscriber.Pass());
   run_loop.Run();
   view->EndFrameSubscription();
 
   EXPECT_LE(1, callback_invoke_count());
   EXPECT_LE(1, frames_captured());
 }
 
 // Test that we can copy twice from an accelerated composited page.
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest, CopyTwice) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   if (!view->CanCopyToVideoFrame()) {
     LOG(WARNING) << ("Blindly passing this test: "
                      "CopyFromCompositingSurfaceToVideoFrame() not supported "
                      "on this platform.");
     return;
   }
 
+#if defined(USE_AURA)
+  if (ui::IsTestCompositorEnabled()) {
+    LOG(WARNING) << ("Blindly passing this test: Aura test compositor doesn't "
+                     "support copying to video frame.");
+    // TODO(jbauman): Aura test compositor should support copying to video
+    // frame. http://crbug.com/268644
+    return;
+  }
+#endif
+
   base::RunLoop run_loop;
   scoped_refptr<media::VideoFrame> first_output =
       media::VideoFrame::CreateBlackFrame(frame_size());
   ASSERT_TRUE(first_output.get());
   scoped_refptr<media::VideoFrame> second_output =
       media::VideoFrame::CreateBlackFrame(frame_size());
   ASSERT_TRUE(second_output.get());
   view->CopyFromCompositingSurfaceToVideoFrame(
       gfx::Rect(view->GetViewBounds().size()),
       first_output,
@@ skipping 16 matching lines @@
 }
 
 class CompositingRenderWidgetHostViewBrowserTestTabCapture
     : public CompositingRenderWidgetHostViewBrowserTest {
  public:
   CompositingRenderWidgetHostViewBrowserTestTabCapture()
       : expected_copy_from_compositing_surface_result_(false),
         allowable_error_(0),
         test_url_("data:text/html,<!doctype html>") {}
 
+  virtual void SetUp() OVERRIDE {
+    ui::DisableTestCompositor();
+    CompositingRenderWidgetHostViewBrowserTest::SetUp();
+  }
+
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    // TODO(Hubbe): This code is very similar to some code in
+    // gpu_feature_browsertest.cc, and should really be shared in a common
+    // location.
+    if (!command_line->HasSwitch(switches::kUseGpuInTests)) {
+      CHECK(!command_line->HasSwitch(switches::kUseGL))
+          << "kUseGL must not be set by test framework code!";
+      command_line->AppendSwitchASCII(switches::kUseGL,
+                                      gfx::kGLImplementationOSMesaName);
+    }
+  }
+
   void CopyFromCompositingSurfaceCallback(base::Closure quit_callback,
                                           bool result,
                                           const SkBitmap& bitmap) {
     EXPECT_EQ(expected_copy_from_compositing_surface_result_, result);
     if (!result) {
       quit_callback.Run();
       return;
     }
 
     const SkBitmap& expected_bitmap =
@@ skipping 378 matching lines @@
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 }  // namespace
 }  // namespace content