Fixed position layer counter-scroll with main thread scroll offset fractional part

cc/layers/layer.cc

 // Copyright 2010 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 "cc/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/debug/trace_event.h"
@@ skipping 651 matching lines @@
     clip_children_ = nullptr;
   SetNeedsCommit();
 }
 
 void Layer::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsPropertyChangeAllowed());
 
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
+  scroll_offset_fractional_part_ = scroll_offset.DeltaFrom(

[aelias_OOO_until_Jul13, 2015/01/28 02:04:00]

I see Dana made the comment on your doc "This seems magical in that blink
positions things at integers since it knows cc will happen to only use the
integer parts of the things it gave. It should have to be more explicit."  In
keeping with that, how about a new API "SetScrollOffsetFractionalPart" to be
called from Blink and leave SetScrollOffset unchanged?

[Yufeng Shen (Slow to review), 2015/01/28 04:49:23]

would an API that takes 2 parameters be better ?
e.g. SetScrollOffset(scroll_offset_integer_part, scroll_offset_fractional_part)

so the caller won't forget to call one without the other.

[aelias_OOO_until_Jul13, 2015/01/28 05:50:29]

I'd rather keep them separate, it makes sense not to call the fractional one if
the fixed-position problem in Blink is fixed at some point.

[Yufeng Shen (Slow to review), 2015/01/28 22:28:09]

Done.

+      gfx::ScrollOffset(gfx::ScrollOffsetToFlooredVector2d(scroll_offset)));
   SetNeedsCommit();
 }
 
 void Layer::SetScrollOffsetFromImplSide(
     const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsPropertyChangeAllowed());
   // This function only gets called during a BeginMainFrame, so there
   // is no need to call SetNeedsUpdate here.
   DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested());
   if (scroll_offset_ == scroll_offset)
@@ skipping 292 matching lines @@
   } else {
     if (layer_animation_controller_
             ->scroll_offset_animation_was_interrupted()) {
       layer->SetScrollOffsetAndDelta(scroll_offset_, gfx::Vector2dF());
     } else {
       layer->SetScrollOffsetAndDelta(
           scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta());
     }
     layer->SetSentScrollDelta(gfx::Vector2dF());
   }
+  layer->SetMainScrollOffsetFractionalPart(scroll_offset_fractional_part_);
 
   // Wrap the copy_requests_ in a PostTask to the main thread.
   ScopedPtrVector<CopyOutputRequest> main_thread_copy_requests;
   for (ScopedPtrVector<CopyOutputRequest>::iterator it = copy_requests_.begin();
        it != copy_requests_.end();
        ++it) {
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
         layer_tree_host()->proxy()->MainThreadTaskRunner();
     scoped_ptr<CopyOutputRequest> original_request = copy_requests_.take(it);
     const CopyOutputRequest& original_request_ref = *original_request;
@@ skipping 300 matching lines @@
 }
 
 void Layer::SetFrameTimingRequests(
     const std::vector<FrameTimingRequest>& requests) {
   frame_timing_requests_ = requests;
   frame_timing_requests_dirty_ = true;
   SetNeedsCommit();
 }
 
 }  // namespace cc