[mus]Add FrameGenerator::SetHighContrastMode(bool)

services/ui/ws/frame_generator_unittest.cc

 // Copyright 2017 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 "services/ui/ws/frame_generator.h"
 
 #include "base/macros.h"
 #include "cc/output/compositor_frame_sink.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/test/begin_frame_args_test.cc"
 #include "cc/test/fake_external_begin_frame_source.h"
-#include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_delegate.h"
 #include "services/ui/ws/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ui {
 namespace ws {
 namespace test {
 
 // TestServerWindowDelegate implements ServerWindowDelegate and returns nullptrs
@@ skipping 73 matching lines @@
       observing_begin_frames_ = false;
     }
     begin_frame_source_ = source;
     UpdateNeedsBeginFramesInternal();
   }
 
   const cc::CompositorFrameMetadata& last_metadata() {
     return last_frame_.metadata;
   }
 
+  const cc::RenderPassList& last_render_pass_list() {
+    return last_frame_.render_pass_list;
+  }
+
   int number_frames_received() { return number_frames_received_; }
 
  private:
   void UpdateNeedsBeginFramesInternal() {
     if (!begin_frame_source_)
       return;
 
     if (needs_begin_frames_ == observing_begin_frames_)
       return;
 
@@ skipping 27 matching lines @@
 
     std::unique_ptr<FakeCompositorFrameSink> compositor_frame_sink =
         base::MakeUnique<FakeCompositorFrameSink>();
     compositor_frame_sink_ = compositor_frame_sink.get();
 
     constexpr float kRefreshRate = 0.f;
     constexpr bool kTickAutomatically = false;
     begin_frame_source_ = base::MakeUnique<cc::FakeExternalBeginFrameSource>(
         kRefreshRate, kTickAutomatically);
     compositor_frame_sink_->SetBeginFrameSource(begin_frame_source_.get());
-    delegate_ = base::MakeUnique<TestFrameGeneratorDelegate>();
     server_window_delegate_ = base::MakeUnique<TestServerWindowDelegate>();
     root_window_ = base::MakeUnique<ServerWindow>(server_window_delegate_.get(),
                                                   WindowId());
     root_window_->SetVisible(true);
     frame_generator_ = base::MakeUnique<FrameGenerator>(
-        delegate_.get(), root_window_.get(), std::move(compositor_frame_sink));
+        root_window_.get(), std::move(compositor_frame_sink));
   };
 
   int NumberOfFramesReceived() {
     return compositor_frame_sink_->number_frames_received();
   }
 
   void IssueBeginFrame() {
     begin_frame_source_->TestOnBeginFrame(cc::CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE, 0, next_sequence_number_));
     ++next_sequence_number_;
   }
 
   FrameGenerator* frame_generator() { return frame_generator_.get(); }
 
   const cc::CompositorFrameMetadata& LastMetadata() {
     return compositor_frame_sink_->last_metadata();
   }
 
+  const cc::RenderPassList& LastRenderPassList() {
+    return compositor_frame_sink_->last_render_pass_list();
+  }
+
  private:
   FakeCompositorFrameSink* compositor_frame_sink_ = nullptr;
   std::unique_ptr<cc::FakeExternalBeginFrameSource> begin_frame_source_;
-  std::unique_ptr<TestFrameGeneratorDelegate> delegate_;
   std::unique_ptr<TestServerWindowDelegate> server_window_delegate_;
   std::unique_ptr<ServerWindow> root_window_;
   std::unique_ptr<FrameGenerator> frame_generator_;
   int next_sequence_number_ = 1;
 
   DISALLOW_COPY_AND_ASSIGN(FrameGeneratorTest);
 };
 
 TEST_F(FrameGeneratorTest, OnSurfaceCreated) {
   EXPECT_EQ(0, NumberOfFramesReceived());
@@ skipping 54 matching lines @@
   const cc::CompositorFrameMetadata& last_metadata = LastMetadata();
   EXPECT_EQ(kDefaultScaleFactor, last_metadata.device_scale_factor);
 
   frame_generator()->SetDeviceScaleFactor(kArbitraryScaleFactor);
   IssueBeginFrame();
   EXPECT_EQ(2, NumberOfFramesReceived());
   const cc::CompositorFrameMetadata& second_last_metadata = LastMetadata();
   EXPECT_EQ(kArbitraryScaleFactor, second_last_metadata.device_scale_factor);
 }
 
+TEST_F(FrameGeneratorTest, SetHighContrastMode) {
+  // FrameGenerator requires a valid SurfaceInfo before generating
+  // CompositorFrames.
+  const cc::SurfaceId kArbitrarySurfaceId(
+      cc::FrameSinkId(1, 1),
+      cc::LocalSurfaceId(1, base::UnguessableToken::Create()));
+  const cc::SurfaceInfo kArbitrarySurfaceInfo(kArbitrarySurfaceId, 1.0f,
+                                              gfx::Size(100, 100));
+  frame_generator()->OnSurfaceCreated(kArbitrarySurfaceInfo);
+  IssueBeginFrame();
+  EXPECT_EQ(1, NumberOfFramesReceived());
+
+  // Changing high contrast mode should trigger a BeginFrame.
+  frame_generator()->SetHighContrastMode(true);
+  IssueBeginFrame();
+  EXPECT_EQ(2, NumberOfFramesReceived());
+
+  // Verify that the last frame has an invert filter.
+  const cc::RenderPassList& render_pass_list = LastRenderPassList();
+  std::vector<cc::FilterOperation> filter_list = {

[Fady Samuel, 2017/03/20 22:03:47]

Do you need this line? can you simply have this inside expected_filters'
constructor?

[Alex Z., 2017/03/20 23:34:23]

Done.

+      cc::FilterOperation::CreateInvertFilter(1.f)};
+  const cc::FilterOperations expected_filters(std::move(filter_list));
+  EXPECT_EQ(expected_filters, render_pass_list.front()->filters);
+}
+
 }  // namespace test
 }  // namespace ws
 }  // namespace ui