mus: Introduce high-contrast mode in mus.

services/ui/ws/frame_generator.cc

 // Copyright 2016 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/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
+#include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "services/ui/surfaces/display_compositor.h"
 #include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_surface.h"
 #include "services/ui/ws/server_window_surface_manager.h"
 
 namespace ui {
 
 namespace ws {
 
 FrameGenerator::FrameGenerator(FrameGeneratorDelegate* delegate,
                                scoped_refptr<GpuState> gpu_state,
                                scoped_refptr<SurfacesState> surfaces_state)
     : delegate_(delegate),
       gpu_state_(gpu_state),
       surfaces_state_(surfaces_state),
       draw_timer_(false, false),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  DCHECK(delegate_);
+}
 
 FrameGenerator::~FrameGenerator() {
   // Invalidate WeakPtrs now to avoid callbacks back into the
   // FrameGenerator during destruction of |display_compositor_|.
   weak_factory_.InvalidateWeakPtrs();
   display_compositor_.reset();
 }
 
 void FrameGenerator::RequestRedraw(const gfx::Rect& redraw_region) {
   dirty_rect_.Union(redraw_region);
@@ skipping 43 matching lines @@
 void FrameGenerator::DidDraw(cc::SurfaceDrawStatus status) {
   frame_pending_ = false;
   delegate_->OnCompositorFrameDrawn();
   if (!dirty_rect_.IsEmpty())
     WantToDraw();
 }
 
 cc::CompositorFrame FrameGenerator::GenerateCompositorFrame() {
   const ViewportMetrics& metrics = delegate_->GetViewportMetrics();
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
-  render_pass->damage_rect = dirty_rect_;
-  render_pass->output_rect = gfx::Rect(metrics.size_in_pixels);
+  gfx::Rect output_rect(metrics.size_in_pixels);
+  dirty_rect_.Intersect(output_rect);
+  const cc::RenderPassId render_pass_id(1, 1);
+  render_pass->SetNew(render_pass_id, output_rect, dirty_rect_,
+                      gfx::Transform());
 
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
                  1.0f);
 
   std::unique_ptr<cc::DelegatedFrameData> frame_data(
       new cc::DelegatedFrameData);
   frame_data->render_pass_list.push_back(std::move(render_pass));
+  if (delegate_->IsInHighContrastMode()) {
+    std::unique_ptr<cc::RenderPass> invert_pass = cc::RenderPass::Create();
+    invert_pass->SetNew(cc::RenderPassId(2, 0), output_rect, dirty_rect_,
+                        gfx::Transform());
+    cc::SharedQuadState* shared_state =
+        invert_pass->CreateAndAppendSharedQuadState();
+    shared_state->SetAll(gfx::Transform(), output_rect.size(), output_rect,
+                         output_rect, false, 1.f, SkXfermode::kSrcOver_Mode, 0);
+    auto* quad = invert_pass->CreateAndAppendDrawQuad<cc::RenderPassDrawQuad>();
+    cc::FilterOperations filters;
+    filters.Append(cc::FilterOperation::CreateInvertFilter(1.f));
+    quad->SetNew(shared_state, output_rect, output_rect, render_pass_id,
+                 0 /* mask_resource_id */, gfx::Vector2dF() /* mask_uv_scale */,
+                 gfx::Size() /* mask_texture_size */, filters,
+                 gfx::Vector2dF() /* filters_scale */,
+                 cc::FilterOperations() /* background_filters */);
+    frame_data->render_pass_list.push_back(std::move(invert_pass));
+  }
 
   cc::CompositorFrame frame;
   frame.delegated_frame_data = std::move(frame_data);
   return frame;
 }
 
 void FrameGenerator::DrawWindowTree(
     cc::RenderPass* pass,
     ServerWindow* window,
     const gfx::Vector2d& parent_to_root_origin_offset,
@@ skipping 64 matching lines @@
     quad->SetAll(sqs, bounds_at_origin /* rect */,
                  gfx::Rect() /* opaque_rect */,
                  bounds_at_origin /* visible_rect */, true /* needs_blending*/,
                  underlay_surface->id());
   }
 }
 
 }  // namespace ws
 
 }  // namespace ui