Plumb SetVisible from ui::Compositor to the DirectRenderer.

ui/compositor/test/in_process_context_factory.h

 // 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.
 
 #ifndef UI_COMPOSITOR_TEST_IN_PROCESS_CONTEXT_FACTORY_H_
 #define UI_COMPOSITOR_TEST_IN_PROCESS_CONTEXT_FACTORY_H_
 
 #include <stdint.h>
 #include <memory>
 
@@ skipping 44 matching lines @@
   scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider() override;
   void RemoveCompositor(Compositor* compositor) override;
   bool DoesCreateTestContexts() override;
   uint32_t GetImageTextureTarget(gfx::BufferFormat format,
                                  gfx::BufferUsage usage) override;
   cc::SharedBitmapManager* GetSharedBitmapManager() override;
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
   cc::TaskGraphRunner* GetTaskGraphRunner() override;
   uint32_t AllocateSurfaceClientId() override;
   cc::SurfaceManager* GetSurfaceManager() override;
+  void SetDisplayVisible(ui::Compositor* compositor, bool visible) override;
   void ResizeDisplay(ui::Compositor* compositor,
                      const gfx::Size& size) override;
   void SetDisplayColorSpace(ui::Compositor* compositor,
                             const gfx::ColorSpace& color_space) override {}
   void SetAuthoritativeVSyncInterval(ui::Compositor* compositor,
                                      base::TimeDelta interval) override {}
   void SetDisplayVSyncParameters(ui::Compositor* compositor,
                                  base::TimeTicks timebase,
                                  base::TimeDelta interval) override {}
   void SetOutputIsSecure(ui::Compositor* compositor, bool secure) override {}
   void AddObserver(ContextFactoryObserver* observer) override;
   void RemoveObserver(ContextFactoryObserver* observer) override;
 
  private:
   scoped_refptr<InProcessContextProvider> shared_main_thread_contexts_;
   scoped_refptr<InProcessContextProvider> shared_worker_context_provider_;
   cc::TestSharedBitmapManager shared_bitmap_manager_;
   cc::TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   cc::TestImageFactory image_factory_;
   cc::TestTaskGraphRunner task_graph_runner_;
   uint32_t next_surface_client_id_;
   bool use_test_surface_;
   bool context_factory_for_test_;
   cc::SurfaceManager* surface_manager_;
   base::ObserverList<ContextFactoryObserver> observer_list_;
 
-  base::hash_map<Compositor*, std::unique_ptr<cc::Display>>
-      per_compositor_data_;
+  struct PerCompositorData {
+    PerCompositorData();
+    ~PerCompositorData();
+
+    PerCompositorData(PerCompositorData&&);
+    PerCompositorData& operator=(PerCompositorData&&);
+
+    bool visible;

[sunnyps, 2016/08/15 23:20:03]

I think you should initialize visible here? (and maybe even display)

[danakj, 2016/08/16 00:37:22]

Oh, yes I should! But actually I looked at this a bit more cuz I was like wait
how are tests passing.

The cacheing in GPTF and here in IPCF was redundant, because we are setting
visibility on the Display when we recreate it from ui::Compositor already, since
the GPTF may not even know about the compositor at times. So we can just use
that as the single place that resets visibility and drop cacheing in the
ContextFactory impls. With that knowledge I've reverted most of the changes in
this class. 

+    std::unique_ptr<cc::Display> display;
+  };
+  base::hash_map<Compositor*, PerCompositorData> per_compositor_data_;
 
   DISALLOW_COPY_AND_ASSIGN(InProcessContextFactory);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_TEST_IN_PROCESS_CONTEXT_FACTORY_H_