Revert of cc: Use worker context for one-copy tile initialization.

ui/compositor/test/in_process_context_factory.cc

 // Copyright 2014 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 "ui/compositor/test/in_process_context_factory.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/threading/thread.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 23 matching lines @@
   ~FakeReflector() override {}
   void OnMirroringCompositorResized() override {}
   void AddMirroringLayer(Layer* layer) override {}
   void RemoveMirroringLayer(Layer* layer) override {}
 };
 
 // An OutputSurface implementation that directly draws and swaps to an actual
 // GL surface.
 class DirectOutputSurface : public cc::OutputSurface {
  public:
-  DirectOutputSurface(
-      const scoped_refptr<cc::ContextProvider>& context_provider,
-      const scoped_refptr<cc::ContextProvider>& worker_context_provider)
-      : cc::OutputSurface(context_provider, worker_context_provider),
-        weak_ptr_factory_(this) {}
+  explicit DirectOutputSurface(
+      const scoped_refptr<cc::ContextProvider>& context_provider)
+      : cc::OutputSurface(context_provider), weak_ptr_factory_(this) {}
 
   ~DirectOutputSurface() override {}
 
   // cc::OutputSurface implementation
   void SwapBuffers(cc::CompositorFrame* frame) override {
     DCHECK(context_provider_.get());
     DCHECK(frame->gl_frame_data);
     if (frame->gl_frame_data->sub_buffer_rect ==
         gfx::Rect(frame->gl_frame_data->size)) {
       context_provider_->ContextSupport()->Swap();
@@ skipping 46 matching lines @@
   attribs.stencil_size = 0;
   attribs.samples = 0;
   attribs.sample_buffers = 0;
   attribs.fail_if_major_perf_caveat = false;
   attribs.bind_generates_resource = false;
 
   scoped_refptr<InProcessContextProvider> context_provider =
       InProcessContextProvider::Create(attribs, &gpu_memory_buffer_manager_,
                                        &image_factory_,
                                        compositor->widget(), "UICompositor");
-  scoped_refptr<InProcessContextProvider> worker_context_provider =
-      InProcessContextProvider::CreateOffscreen(&gpu_memory_buffer_manager_,
-                                                &image_factory_);
 
   scoped_ptr<cc::OutputSurface> real_output_surface;
 
   if (use_test_surface_) {
     bool flipped_output_surface = false;
     real_output_surface = make_scoped_ptr(new cc::PixelTestOutputSurface(
-        context_provider, worker_context_provider, flipped_output_surface));
+        context_provider, flipped_output_surface));
   } else {
-    real_output_surface = make_scoped_ptr(
-        new DirectOutputSurface(context_provider, worker_context_provider));
+    real_output_surface =
+        make_scoped_ptr(new DirectOutputSurface(context_provider));
   }
 
   if (surface_manager_) {
     scoped_ptr<cc::OnscreenDisplayClient> display_client(
         new cc::OnscreenDisplayClient(
             real_output_surface.Pass(), surface_manager_,
             GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
             compositor->GetRendererSettings(), compositor->task_runner()));
     scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
-        new cc::SurfaceDisplayOutputSurface(
-            surface_manager_, compositor->surface_id_allocator(),
-            context_provider, worker_context_provider));
+        new cc::SurfaceDisplayOutputSurface(surface_manager_,
+                                            compositor->surface_id_allocator(),
+                                            context_provider));
     display_client->set_surface_output_surface(surface_output_surface.get());
     surface_output_surface->set_display_client(display_client.get());
 
     compositor->SetOutputSurface(surface_output_surface.Pass());
 
     delete per_compositor_data_[compositor.get()];
     per_compositor_data_[compositor.get()] = display_client.release();
   } else {
     compositor->SetOutputSurface(real_output_surface.Pass());
   }
@@ skipping 62 matching lines @@
 }
 
 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor,
                                             const gfx::Size& size) {
   if (!per_compositor_data_.count(compositor))
     return;
   per_compositor_data_[compositor]->display()->Resize(size);
 }
 
 }  // namespace ui