OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ui/compositor/layer.h" | 5 #include "ui/compositor/layer.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/command_line.h" | 9 #include "base/command_line.h" |
10 #include "base/debug/trace_event.h" | 10 #include "base/debug/trace_event.h" |
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
201 | 201 |
202 void Layer::SetTransform(const gfx::Transform& transform) { | 202 void Layer::SetTransform(const gfx::Transform& transform) { |
203 GetAnimator()->SetTransform(transform); | 203 GetAnimator()->SetTransform(transform); |
204 } | 204 } |
205 | 205 |
206 gfx::Transform Layer::GetTargetTransform() const { | 206 gfx::Transform Layer::GetTargetTransform() const { |
207 if (animator_.get() && animator_->IsAnimatingProperty( | 207 if (animator_.get() && animator_->IsAnimatingProperty( |
208 LayerAnimationElement::TRANSFORM)) { | 208 LayerAnimationElement::TRANSFORM)) { |
209 return animator_->GetTargetTransform(); | 209 return animator_->GetTargetTransform(); |
210 } | 210 } |
211 return transform_; | 211 return transform(); |
212 } | 212 } |
213 | 213 |
214 void Layer::SetBounds(const gfx::Rect& bounds) { | 214 void Layer::SetBounds(const gfx::Rect& bounds) { |
215 GetAnimator()->SetBounds(bounds); | 215 GetAnimator()->SetBounds(bounds); |
216 } | 216 } |
217 | 217 |
218 gfx::Rect Layer::GetTargetBounds() const { | 218 gfx::Rect Layer::GetTargetBounds() const { |
219 if (animator_.get() && animator_->IsAnimatingProperty( | 219 if (animator_.get() && animator_->IsAnimatingProperty( |
220 LayerAnimationElement::BOUNDS)) { | 220 LayerAnimationElement::BOUNDS)) { |
221 return animator_->GetTargetBounds(); | 221 return animator_->GetTargetBounds(); |
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
411 | 411 |
412 const Layer* root_layer = GetRoot(source); | 412 const Layer* root_layer = GetRoot(source); |
413 CHECK_EQ(root_layer, GetRoot(target)); | 413 CHECK_EQ(root_layer, GetRoot(target)); |
414 | 414 |
415 if (source != root_layer) | 415 if (source != root_layer) |
416 source->ConvertPointForAncestor(root_layer, point); | 416 source->ConvertPointForAncestor(root_layer, point); |
417 if (target != root_layer) | 417 if (target != root_layer) |
418 target->ConvertPointFromAncestor(root_layer, point); | 418 target->ConvertPointFromAncestor(root_layer, point); |
419 } | 419 } |
420 | 420 |
| 421 // static |
| 422 gfx::Transform Layer::ConvertTransformToCCTransform( |
| 423 const gfx::Transform& transform, |
| 424 const gfx::Rect& bounds, |
| 425 float device_scale_factor) { |
| 426 gfx::Transform cc_transform; |
| 427 cc_transform.Scale(device_scale_factor, device_scale_factor); |
| 428 cc_transform.Translate(bounds.x(), bounds.y()); |
| 429 cc_transform.PreconcatTransform(transform); |
| 430 cc_transform.Scale(1.0f / device_scale_factor, 1.0f / device_scale_factor); |
| 431 return cc_transform; |
| 432 } |
| 433 |
421 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) { | 434 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) { |
422 if (fills_bounds_opaquely_ == fills_bounds_opaquely) | 435 if (fills_bounds_opaquely_ == fills_bounds_opaquely) |
423 return; | 436 return; |
424 | 437 |
425 fills_bounds_opaquely_ = fills_bounds_opaquely; | 438 fills_bounds_opaquely_ = fills_bounds_opaquely; |
426 | 439 |
427 cc_layer_->SetContentsOpaque(fills_bounds_opaquely); | 440 cc_layer_->SetContentsOpaque(fills_bounds_opaquely); |
428 } | 441 } |
429 | 442 |
430 void Layer::SwitchToLayer(scoped_refptr<cc::Layer> new_layer) { | 443 void Layer::SwitchToLayer(scoped_refptr<cc::Layer> new_layer) { |
431 if (texture_layer_.get()) | 444 if (texture_layer_.get()) |
432 texture_layer_->willModifyTexture(); | 445 texture_layer_->willModifyTexture(); |
433 // TODO(piman): delegated_renderer_layer_ cleanup. | 446 // TODO(piman): delegated_renderer_layer_ cleanup. |
434 | 447 |
435 cc_layer_->RemoveAllChildren(); | 448 cc_layer_->RemoveAllChildren(); |
436 if (parent_) { | 449 if (parent_) { |
437 DCHECK(parent_->cc_layer_); | 450 DCHECK(parent_->cc_layer_); |
438 parent_->cc_layer_->ReplaceChild(cc_layer_, new_layer); | 451 parent_->cc_layer_->ReplaceChild(cc_layer_, new_layer); |
439 } | 452 } |
440 cc_layer_->RemoveLayerAnimationEventObserver(this); | 453 cc_layer_->RemoveLayerAnimationEventObserver(this); |
441 new_layer->SetOpacity(cc_layer_->opacity()); | 454 new_layer->SetOpacity(cc_layer_->opacity()); |
| 455 new_layer->SetTransform(cc_layer_->transform()); |
442 | 456 |
443 cc_layer_= new_layer; | 457 cc_layer_= new_layer; |
444 content_layer_ = NULL; | 458 content_layer_ = NULL; |
445 solid_color_layer_ = NULL; | 459 solid_color_layer_ = NULL; |
446 texture_layer_ = NULL; | 460 texture_layer_ = NULL; |
447 delegated_renderer_layer_ = NULL; | 461 delegated_renderer_layer_ = NULL; |
448 | 462 |
449 cc_layer_->AddLayerAnimationEventObserver(this); | 463 cc_layer_->AddLayerAnimationEventObserver(this); |
450 for (size_t i = 0; i < children_.size(); ++i) { | 464 for (size_t i = 0; i < children_.size(); ++i) { |
451 DCHECK(children_[i]->cc_layer_); | 465 DCHECK(children_[i]->cc_layer_); |
(...skipping 18 matching lines...) Expand all Loading... |
470 cc::TextureLayer::Create(this); | 484 cc::TextureLayer::Create(this); |
471 new_layer->setFlipped(texture_->flipped()); | 485 new_layer->setFlipped(texture_->flipped()); |
472 SwitchToLayer(new_layer); | 486 SwitchToLayer(new_layer); |
473 texture_layer_ = new_layer; | 487 texture_layer_ = new_layer; |
474 } else { | 488 } else { |
475 scoped_refptr<cc::ContentLayer> new_layer = | 489 scoped_refptr<cc::ContentLayer> new_layer = |
476 cc::ContentLayer::Create(this); | 490 cc::ContentLayer::Create(this); |
477 SwitchToLayer(new_layer); | 491 SwitchToLayer(new_layer); |
478 content_layer_ = new_layer; | 492 content_layer_ = new_layer; |
479 } | 493 } |
480 RecomputeTransform(); | |
481 } | 494 } |
482 RecomputeDrawsContentAndUVRect(); | 495 RecomputeDrawsContentAndUVRect(); |
483 } | 496 } |
484 | 497 |
485 void Layer::SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame, | 498 void Layer::SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame, |
486 gfx::Size frame_size_in_dip) { | 499 gfx::Size frame_size_in_dip) { |
487 DCHECK_EQ(type_, LAYER_TEXTURED); | 500 DCHECK_EQ(type_, LAYER_TEXTURED); |
488 bool has_frame = frame.get() && !frame->render_pass_list.empty(); | 501 bool has_frame = frame.get() && !frame->render_pass_list.empty(); |
489 layer_updated_externally_ = has_frame; | 502 layer_updated_externally_ = has_frame; |
490 delegated_frame_size_in_dip_ = frame_size_in_dip; | 503 delegated_frame_size_in_dip_ = frame_size_in_dip; |
491 if (!!delegated_renderer_layer_ != has_frame) { | 504 if (!!delegated_renderer_layer_ != has_frame) { |
492 if (has_frame) { | 505 if (has_frame) { |
493 scoped_refptr<cc::DelegatedRendererLayer> new_layer = | 506 scoped_refptr<cc::DelegatedRendererLayer> new_layer = |
494 cc::DelegatedRendererLayer::Create(); | 507 cc::DelegatedRendererLayer::Create(); |
495 SwitchToLayer(new_layer); | 508 SwitchToLayer(new_layer); |
496 delegated_renderer_layer_ = new_layer; | 509 delegated_renderer_layer_ = new_layer; |
497 } else { | 510 } else { |
498 scoped_refptr<cc::ContentLayer> new_layer = | 511 scoped_refptr<cc::ContentLayer> new_layer = |
499 cc::ContentLayer::Create(this); | 512 cc::ContentLayer::Create(this); |
500 SwitchToLayer(new_layer); | 513 SwitchToLayer(new_layer); |
501 content_layer_ = new_layer; | 514 content_layer_ = new_layer; |
502 } | 515 } |
503 RecomputeTransform(); | |
504 } | 516 } |
505 if (has_frame) | 517 if (has_frame) |
506 delegated_renderer_layer_->SetFrameData(frame.Pass()); | 518 delegated_renderer_layer_->SetFrameData(frame.Pass()); |
507 RecomputeDrawsContentAndUVRect(); | 519 RecomputeDrawsContentAndUVRect(); |
508 } | 520 } |
509 | 521 |
510 void Layer::TakeUnusedResourcesForChildCompositor( | 522 void Layer::TakeUnusedResourcesForChildCompositor( |
511 cc::TransferableResourceArray* list) { | 523 cc::TransferableResourceArray* list) { |
512 if (delegated_renderer_layer_) | 524 if (delegated_renderer_layer_) |
513 delegated_renderer_layer_->TakeUnusedResourcesForChildCompositor(list); | 525 delegated_renderer_layer_->TakeUnusedResourcesForChildCompositor(list); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
560 if (!delegate_) | 572 if (!delegate_) |
561 return; | 573 return; |
562 delegate_ = NULL; | 574 delegate_ = NULL; |
563 for (size_t i = 0; i < children_.size(); ++i) | 575 for (size_t i = 0; i < children_.size(); ++i) |
564 children_[i]->SuppressPaint(); | 576 children_[i]->SuppressPaint(); |
565 } | 577 } |
566 | 578 |
567 void Layer::OnDeviceScaleFactorChanged(float device_scale_factor) { | 579 void Layer::OnDeviceScaleFactorChanged(float device_scale_factor) { |
568 if (device_scale_factor_ == device_scale_factor) | 580 if (device_scale_factor_ == device_scale_factor) |
569 return; | 581 return; |
| 582 if (animator_) |
| 583 animator_->StopAnimatingProperty(LayerAnimationElement::TRANSFORM); |
| 584 gfx::Transform transform = this->transform(); |
570 device_scale_factor_ = device_scale_factor; | 585 device_scale_factor_ = device_scale_factor; |
571 RecomputeTransform(); | 586 RecomputeCCTransformFromTransform(transform); |
572 RecomputeDrawsContentAndUVRect(); | 587 RecomputeDrawsContentAndUVRect(); |
573 SchedulePaint(gfx::Rect(bounds_.size())); | 588 SchedulePaint(gfx::Rect(bounds_.size())); |
574 if (delegate_) | 589 if (delegate_) |
575 delegate_->OnDeviceScaleFactorChanged(device_scale_factor); | 590 delegate_->OnDeviceScaleFactorChanged(device_scale_factor); |
576 for (size_t i = 0; i < children_.size(); ++i) | 591 for (size_t i = 0; i < children_.size(); ++i) |
577 children_[i]->OnDeviceScaleFactorChanged(device_scale_factor); | 592 children_[i]->OnDeviceScaleFactorChanged(device_scale_factor); |
578 if (layer_mask_) | 593 if (layer_mask_) |
579 layer_mask_->OnDeviceScaleFactorChanged(device_scale_factor); | 594 layer_mask_->OnDeviceScaleFactorChanged(device_scale_factor); |
580 } | 595 } |
581 | 596 |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
682 } | 697 } |
683 | 698 |
684 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) { | 699 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) { |
685 if (bounds == bounds_) | 700 if (bounds == bounds_) |
686 return; | 701 return; |
687 | 702 |
688 base::Closure closure; | 703 base::Closure closure; |
689 if (delegate_) | 704 if (delegate_) |
690 closure = delegate_->PrepareForLayerBoundsChange(); | 705 closure = delegate_->PrepareForLayerBoundsChange(); |
691 bool was_move = bounds_.size() == bounds.size(); | 706 bool was_move = bounds_.size() == bounds.size(); |
| 707 gfx::Transform transform = this->transform(); |
692 bounds_ = bounds; | 708 bounds_ = bounds; |
693 | 709 |
694 RecomputeTransform(); | 710 RecomputeCCTransformFromTransform(transform); |
695 RecomputeDrawsContentAndUVRect(); | 711 RecomputeDrawsContentAndUVRect(); |
696 if (!closure.is_null()) | 712 if (!closure.is_null()) |
697 closure.Run(); | 713 closure.Run(); |
698 | 714 |
699 if (was_move) { | 715 if (was_move) { |
700 // Don't schedule a draw if we're invisible. We'll schedule one | 716 // Don't schedule a draw if we're invisible. We'll schedule one |
701 // automatically when we get visible. | 717 // automatically when we get visible. |
702 if (IsDrawn()) | 718 if (IsDrawn()) |
703 ScheduleDraw(); | 719 ScheduleDraw(); |
704 } else { | 720 } else { |
705 // Always schedule a paint, even if we're invisible. | 721 // Always schedule a paint, even if we're invisible. |
706 SchedulePaint(gfx::Rect(bounds.size())); | 722 SchedulePaint(gfx::Rect(bounds.size())); |
707 } | 723 } |
708 } | 724 } |
709 | 725 |
710 void Layer::SetTransformImmediately(const gfx::Transform& transform) { | 726 void Layer::SetTransformImmediately(const gfx::Transform& transform) { |
711 transform_ = transform; | 727 RecomputeCCTransformFromTransform(transform); |
712 | |
713 RecomputeTransform(); | |
714 } | 728 } |
715 | 729 |
716 void Layer::SetOpacityImmediately(float opacity) { | 730 void Layer::SetOpacityImmediately(float opacity) { |
717 cc_layer_->SetOpacity(opacity); | 731 cc_layer_->SetOpacity(opacity); |
718 ScheduleDraw(); | 732 ScheduleDraw(); |
719 } | 733 } |
720 | 734 |
721 void Layer::SetVisibilityImmediately(bool visible) { | 735 void Layer::SetVisibilityImmediately(bool visible) { |
722 if (visible_ == visible) | 736 if (visible_ == visible) |
723 return; | 737 return; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
772 } | 786 } |
773 | 787 |
774 void Layer::ScheduleDrawForAnimation() { | 788 void Layer::ScheduleDrawForAnimation() { |
775 ScheduleDraw(); | 789 ScheduleDraw(); |
776 } | 790 } |
777 | 791 |
778 const gfx::Rect& Layer::GetBoundsForAnimation() const { | 792 const gfx::Rect& Layer::GetBoundsForAnimation() const { |
779 return bounds(); | 793 return bounds(); |
780 } | 794 } |
781 | 795 |
782 const gfx::Transform& Layer::GetTransformForAnimation() const { | 796 gfx::Transform Layer::GetTransformForAnimation() const { |
783 return transform(); | 797 return transform(); |
784 } | 798 } |
785 | 799 |
786 float Layer::GetOpacityForAnimation() const { | 800 float Layer::GetOpacityForAnimation() const { |
787 return opacity(); | 801 return opacity(); |
788 } | 802 } |
789 | 803 |
790 bool Layer::GetVisibilityForAnimation() const { | 804 bool Layer::GetVisibilityForAnimation() const { |
791 return visible(); | 805 return visible(); |
792 } | 806 } |
793 | 807 |
794 float Layer::GetBrightnessForAnimation() const { | 808 float Layer::GetBrightnessForAnimation() const { |
795 return layer_brightness(); | 809 return layer_brightness(); |
796 } | 810 } |
797 | 811 |
798 float Layer::GetGrayscaleForAnimation() const { | 812 float Layer::GetGrayscaleForAnimation() const { |
799 return layer_grayscale(); | 813 return layer_grayscale(); |
800 } | 814 } |
801 | 815 |
802 SkColor Layer::GetColorForAnimation() const { | 816 SkColor Layer::GetColorForAnimation() const { |
803 // WebColor is equivalent to SkColor, per WebColor.h. | 817 // WebColor is equivalent to SkColor, per WebColor.h. |
804 // The NULL check is here since this is invoked regardless of whether we have | 818 // The NULL check is here since this is invoked regardless of whether we have |
805 // been configured as LAYER_SOLID_COLOR. | 819 // been configured as LAYER_SOLID_COLOR. |
806 return solid_color_layer_.get() ? | 820 return solid_color_layer_.get() ? |
807 solid_color_layer_->background_color() : SK_ColorBLACK; | 821 solid_color_layer_->background_color() : SK_ColorBLACK; |
808 } | 822 } |
809 | 823 |
| 824 float Layer::GetDeviceScaleFactor() const { |
| 825 return device_scale_factor_; |
| 826 } |
| 827 |
810 void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) { | 828 void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) { |
811 DCHECK(cc_layer_); | 829 DCHECK(cc_layer_); |
812 // Until this layer has a compositor (and hence cc_layer_ has a | 830 // Until this layer has a compositor (and hence cc_layer_ has a |
813 // LayerTreeHost), addAnimation will fail. | 831 // LayerTreeHost), addAnimation will fail. |
814 if (GetCompositor()) | 832 if (GetCompositor()) |
815 cc_layer_->AddAnimation(animation.Pass()); | 833 cc_layer_->AddAnimation(animation.Pass()); |
816 else | 834 else |
817 pending_threaded_animations_.push_back(animation.Pass()); | 835 pending_threaded_animations_.push_back(animation.Pass()); |
818 } | 836 } |
819 | 837 |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
868 } else { | 886 } else { |
869 content_layer_ = cc::ContentLayer::Create(this); | 887 content_layer_ = cc::ContentLayer::Create(this); |
870 cc_layer_ = content_layer_.get(); | 888 cc_layer_ = content_layer_.get(); |
871 } | 889 } |
872 cc_layer_->SetAnchorPoint(gfx::PointF()); | 890 cc_layer_->SetAnchorPoint(gfx::PointF()); |
873 cc_layer_->SetContentsOpaque(true); | 891 cc_layer_->SetContentsOpaque(true); |
874 cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN); | 892 cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN); |
875 cc_layer_->AddLayerAnimationEventObserver(this); | 893 cc_layer_->AddLayerAnimationEventObserver(this); |
876 } | 894 } |
877 | 895 |
878 void Layer::RecomputeTransform() { | 896 void Layer::RecomputeCCTransformFromTransform(const gfx::Transform& transform) { |
879 gfx::Transform scale_translate; | 897 cc_layer_->SetTransform(ConvertTransformToCCTransform(transform, |
880 scale_translate.matrix().set3x3(device_scale_factor_, 0, 0, | 898 bounds_, |
881 0, device_scale_factor_, 0, | 899 device_scale_factor_)); |
882 0, 0, 1); | 900 } |
883 // Start with the inverse matrix of above. | 901 |
| 902 gfx::Transform Layer::transform() const { |
884 gfx::Transform transform; | 903 gfx::Transform transform; |
885 transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0, | 904 transform.Translate(-bounds_.x(), -bounds_.y()); |
886 0, 1.0f / device_scale_factor_, 0, | 905 transform.Scale(1.0f / device_scale_factor_, 1.0f / device_scale_factor_); |
887 0, 0, 1); | 906 transform.PreconcatTransform(cc_layer_->transform()); |
888 transform.ConcatTransform(transform_); | 907 transform.Scale(device_scale_factor_, device_scale_factor_); |
889 gfx::Transform translate; | 908 return transform; |
890 translate.Translate(bounds_.x(), bounds_.y()); | |
891 transform.ConcatTransform(translate); | |
892 transform.ConcatTransform(scale_translate); | |
893 cc_layer_->SetTransform(transform); | |
894 } | 909 } |
895 | 910 |
896 void Layer::RecomputeDrawsContentAndUVRect() { | 911 void Layer::RecomputeDrawsContentAndUVRect() { |
897 DCHECK(cc_layer_); | 912 DCHECK(cc_layer_); |
898 gfx::Size size(bounds_.size()); | 913 gfx::Size size(bounds_.size()); |
899 if (texture_layer_.get()) { | 914 if (texture_layer_.get()) { |
900 DCHECK(texture_); | 915 DCHECK(texture_); |
901 | 916 |
902 float texture_scale_factor = 1.0f / texture_->device_scale_factor(); | 917 float texture_scale_factor = 1.0f / texture_->device_scale_factor(); |
903 gfx::Size texture_size = gfx::ToFlooredSize( | 918 gfx::Size texture_size = gfx::ToFlooredSize( |
904 gfx::ScaleSize(texture_->size(), texture_scale_factor)); | 919 gfx::ScaleSize(texture_->size(), texture_scale_factor)); |
905 size.ClampToMax(texture_size); | 920 size.ClampToMax(texture_size); |
906 | 921 |
907 gfx::PointF uv_top_left(0.f, 0.f); | 922 gfx::PointF uv_top_left(0.f, 0.f); |
908 gfx::PointF uv_bottom_right( | 923 gfx::PointF uv_bottom_right( |
909 static_cast<float>(size.width())/texture_size.width(), | 924 static_cast<float>(size.width())/texture_size.width(), |
910 static_cast<float>(size.height())/texture_size.height()); | 925 static_cast<float>(size.height())/texture_size.height()); |
911 texture_layer_->setUV(uv_top_left, uv_bottom_right); | 926 texture_layer_->setUV(uv_top_left, uv_bottom_right); |
912 } else if (delegated_renderer_layer_.get()) { | 927 } else if (delegated_renderer_layer_.get()) { |
913 delegated_renderer_layer_->SetDisplaySize( | 928 delegated_renderer_layer_->SetDisplaySize( |
914 ConvertSizeToPixel(this, delegated_frame_size_in_dip_)); | 929 ConvertSizeToPixel(this, delegated_frame_size_in_dip_)); |
915 size.ClampToMax(delegated_frame_size_in_dip_); | 930 size.ClampToMax(delegated_frame_size_in_dip_); |
916 } | 931 } |
917 cc_layer_->SetBounds(ConvertSizeToPixel(this, size)); | 932 cc_layer_->SetBounds(ConvertSizeToPixel(this, size)); |
918 } | 933 } |
919 | 934 |
920 } // namespace ui | 935 } // namespace ui |
OLD | NEW |