Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(60)

Side by Side Diff: content/browser/renderer_host/render_widget_host_view_android.cc

Issue 2096493002: Make cc::CompositorFrames movable [Part 1 of 2] (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Addressed Dana's nits Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 "content/browser/renderer_host/render_widget_host_view_android.h" 5 #include "content/browser/renderer_host/render_widget_host_view_android.h"
6 6
7 #include <android/bitmap.h> 7 #include <android/bitmap.h>
8 8
9 #include <utility> 9 #include <utility>
10 10
(...skipping 271 matching lines...) Expand 10 before | Expand all | Expand 10 after
282 282
283 rect.Union(controller.GetStartHandleRect()); 283 rect.Union(controller.GetStartHandleRect());
284 rect.Union(controller.GetEndHandleRect()); 284 rect.Union(controller.GetEndHandleRect());
285 return rect; 285 return rect;
286 } 286 }
287 287
288 } // anonymous namespace 288 } // anonymous namespace
289 289
290 RenderWidgetHostViewAndroid::LastFrameInfo::LastFrameInfo( 290 RenderWidgetHostViewAndroid::LastFrameInfo::LastFrameInfo(
291 uint32_t output_id, 291 uint32_t output_id,
292 std::unique_ptr<cc::CompositorFrame> output_frame) 292 cc::CompositorFrame output_frame)
293 : output_surface_id(output_id), frame(std::move(output_frame)) {} 293 : output_surface_id(output_id), frame(std::move(output_frame)) {}
294 294
295 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {} 295 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
296 296
297 void RenderWidgetHostViewAndroid::OnContextLost() { 297 void RenderWidgetHostViewAndroid::OnContextLost() {
298 std::unique_ptr<RenderWidgetHostIterator> widgets( 298 std::unique_ptr<RenderWidgetHostIterator> widgets(
299 RenderWidgetHostImpl::GetAllRenderWidgetHosts()); 299 RenderWidgetHostImpl::GetAllRenderWidgetHosts());
300 while (RenderWidgetHost* widget = widgets->GetNextHost()) { 300 while (RenderWidgetHost* widget = widgets->GetNextHost()) {
301 if (widget->GetView()) { 301 if (widget->GetView()) {
302 static_cast<RenderWidgetHostViewAndroid*>(widget->GetView()) 302 static_cast<RenderWidgetHostViewAndroid*>(widget->GetView())
(...skipping 685 matching lines...) Expand 10 before | Expand all | Expand 10 after
988 return; 988 return;
989 DestroyDelegatedContent(); 989 DestroyDelegatedContent();
990 surface_factory_.reset(); 990 surface_factory_.reset();
991 if (!surface_returned_resources_.empty()) 991 if (!surface_returned_resources_.empty())
992 SendReturnedDelegatedResources(last_output_surface_id_); 992 SendReturnedDelegatedResources(last_output_surface_id_);
993 993
994 last_output_surface_id_ = output_surface_id; 994 last_output_surface_id_ = output_surface_id;
995 } 995 }
996 996
997 void RenderWidgetHostViewAndroid::SubmitCompositorFrame( 997 void RenderWidgetHostViewAndroid::SubmitCompositorFrame(
998 std::unique_ptr<cc::CompositorFrame> frame) { 998 cc::CompositorFrame frame) {
999 cc::SurfaceManager* manager = CompositorImpl::GetSurfaceManager(); 999 cc::SurfaceManager* manager = CompositorImpl::GetSurfaceManager();
1000 if (!surface_factory_) { 1000 if (!surface_factory_) {
1001 surface_factory_ = base::WrapUnique(new cc::SurfaceFactory(manager, this)); 1001 surface_factory_ = base::WrapUnique(new cc::SurfaceFactory(manager, this));
1002 } 1002 }
1003 if (surface_id_.is_null() || 1003 if (surface_id_.is_null() ||
1004 texture_size_in_layer_ != current_surface_size_ || 1004 texture_size_in_layer_ != current_surface_size_ ||
1005 location_bar_content_translation_ != 1005 location_bar_content_translation_ !=
1006 frame->metadata.location_bar_content_translation || 1006 frame.metadata.location_bar_content_translation ||
1007 current_viewport_selection_ != frame->metadata.selection) { 1007 current_viewport_selection_ != frame.metadata.selection) {
1008 RemoveLayers(); 1008 RemoveLayers();
1009 if (!surface_id_.is_null()) 1009 if (!surface_id_.is_null())
1010 surface_factory_->Destroy(surface_id_); 1010 surface_factory_->Destroy(surface_id_);
1011 surface_id_ = id_allocator_->GenerateId(); 1011 surface_id_ = id_allocator_->GenerateId();
1012 surface_factory_->Create(surface_id_); 1012 surface_factory_->Create(surface_id_);
1013 layer_ = CreateDelegatedLayer(); 1013 layer_ = CreateDelegatedLayer();
1014 1014
1015 DCHECK(layer_); 1015 DCHECK(layer_);
1016 1016
1017 current_surface_size_ = texture_size_in_layer_; 1017 current_surface_size_ = texture_size_in_layer_;
1018 location_bar_content_translation_ = 1018 location_bar_content_translation_ =
1019 frame->metadata.location_bar_content_translation; 1019 frame.metadata.location_bar_content_translation;
1020 current_viewport_selection_ = frame->metadata.selection; 1020 current_viewport_selection_ = frame.metadata.selection;
1021 AttachLayers(); 1021 AttachLayers();
1022 } 1022 }
1023 1023
1024 cc::SurfaceFactory::DrawCallback ack_callback = 1024 cc::SurfaceFactory::DrawCallback ack_callback =
1025 base::Bind(&RenderWidgetHostViewAndroid::RunAckCallbacks, 1025 base::Bind(&RenderWidgetHostViewAndroid::RunAckCallbacks,
1026 weak_ptr_factory_.GetWeakPtr()); 1026 weak_ptr_factory_.GetWeakPtr());
1027 surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame), 1027 std::unique_ptr<cc::CompositorFrame> frame_copy(new cc::CompositorFrame);
1028 *frame_copy = std::move(frame);
1029 surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame_copy),
1028 ack_callback); 1030 ack_callback);
1029 } 1031 }
1030 1032
1031 void RenderWidgetHostViewAndroid::SwapDelegatedFrame( 1033 void RenderWidgetHostViewAndroid::SwapDelegatedFrame(
1032 uint32_t output_surface_id, 1034 uint32_t output_surface_id,
1033 std::unique_ptr<cc::CompositorFrame> frame) { 1035 cc::CompositorFrame frame) {
1034 CheckOutputSurfaceChanged(output_surface_id); 1036 CheckOutputSurfaceChanged(output_surface_id);
1035 bool has_content = !texture_size_in_layer_.IsEmpty(); 1037 bool has_content = !texture_size_in_layer_.IsEmpty();
1036 1038
1037 // DelegatedRendererLayerImpl applies the inverse device_scale_factor of the 1039 // DelegatedRendererLayerImpl applies the inverse device_scale_factor of the
1038 // renderer frame, assuming that the browser compositor will scale 1040 // renderer frame, assuming that the browser compositor will scale
1039 // it back up to device scale. But on Android we put our browser layers in 1041 // it back up to device scale. But on Android we put our browser layers in
1040 // physical pixels and set our browser CC device_scale_factor to 1, so this 1042 // physical pixels and set our browser CC device_scale_factor to 1, so this
1041 // suppresses the transform. This line may need to be removed when fixing 1043 // suppresses the transform. This line may need to be removed when fixing
1042 // http://crbug.com/384134 or http://crbug.com/310763 1044 // http://crbug.com/384134 or http://crbug.com/310763
1043 frame->delegated_frame_data->device_scale_factor = 1.0f; 1045 frame.delegated_frame_data->device_scale_factor = 1.0f;
1044 1046
1045 base::Closure ack_callback = 1047 base::Closure ack_callback =
1046 base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck, 1048 base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
1047 weak_ptr_factory_.GetWeakPtr(), 1049 weak_ptr_factory_.GetWeakPtr(),
1048 output_surface_id); 1050 output_surface_id);
1049 1051
1050 ack_callbacks_.push(ack_callback); 1052 ack_callbacks_.push(ack_callback);
1051 1053
1052 if (!has_content) { 1054 if (!has_content) {
1053 DestroyDelegatedContent(); 1055 DestroyDelegatedContent();
1054 } else { 1056 } else {
1055 SubmitCompositorFrame(std::move(frame)); 1057 SubmitCompositorFrame(std::move(frame));
1056 } 1058 }
1057 1059
1058 if (layer_.get()) { 1060 if (layer_.get()) {
1059 layer_->SetIsDrawable(true); 1061 layer_->SetIsDrawable(true);
1060 layer_->SetContentsOpaque(true); 1062 layer_->SetContentsOpaque(true);
1061 layer_->SetBounds(texture_size_in_layer_); 1063 layer_->SetBounds(texture_size_in_layer_);
1062 } 1064 }
1063 1065
1064 if (host_->is_hidden()) 1066 if (host_->is_hidden())
1065 RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED); 1067 RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
1066 } 1068 }
1067 1069
1068 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame( 1070 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
1069 uint32_t output_surface_id, 1071 uint32_t output_surface_id,
1070 std::unique_ptr<cc::CompositorFrame> frame) { 1072 cc::CompositorFrame frame) {
1071 last_scroll_offset_ = frame->metadata.root_scroll_offset; 1073 last_scroll_offset_ = frame.metadata.root_scroll_offset;
1072 if (!frame->delegated_frame_data) { 1074 if (!frame.delegated_frame_data) {
1073 LOG(ERROR) << "Non-delegated renderer path no longer supported"; 1075 LOG(ERROR) << "Non-delegated renderer path no longer supported";
1074 return; 1076 return;
1075 } 1077 }
1076 1078
1077 if (locks_on_frame_count_ > 0) { 1079 if (locks_on_frame_count_ > 0) {
1078 DCHECK(HasValidFrame()); 1080 DCHECK(HasValidFrame());
1079 RetainFrame(output_surface_id, std::move(frame)); 1081 RetainFrame(output_surface_id, std::move(frame));
1080 return; 1082 return;
1081 } 1083 }
1082 1084
1083 if (!CompositorImpl::GetSurfaceManager() && layer_.get() && 1085 if (!CompositorImpl::GetSurfaceManager() && layer_.get() &&
1084 layer_->layer_tree_host()) { 1086 layer_->layer_tree_host()) {
1085 for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) { 1087 for (size_t i = 0; i < frame.metadata.latency_info.size(); i++) {
1086 std::unique_ptr<cc::SwapPromise> swap_promise( 1088 std::unique_ptr<cc::SwapPromise> swap_promise(
1087 new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i])); 1089 new cc::LatencyInfoSwapPromise(frame.metadata.latency_info[i]));
1088 layer_->layer_tree_host()->QueueSwapPromise(std::move(swap_promise)); 1090 layer_->layer_tree_host()->QueueSwapPromise(std::move(swap_promise));
1089 } 1091 }
1090 } 1092 }
1091 1093
1092 DCHECK(!frame->delegated_frame_data->render_pass_list.empty()); 1094 DCHECK(!frame.delegated_frame_data->render_pass_list.empty());
1093 1095
1094 cc::RenderPass* root_pass = 1096 cc::RenderPass* root_pass =
1095 frame->delegated_frame_data->render_pass_list.back().get(); 1097 frame.delegated_frame_data->render_pass_list.back().get();
1096 texture_size_in_layer_ = root_pass->output_rect.size(); 1098 texture_size_in_layer_ = root_pass->output_rect.size();
1097 1099
1098 cc::CompositorFrameMetadata metadata = frame->metadata; 1100 cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
1099 1101
1100 SwapDelegatedFrame(output_surface_id, std::move(frame)); 1102 SwapDelegatedFrame(output_surface_id, std::move(frame));
1101 frame_evictor_->SwappedFrame(!host_->is_hidden()); 1103 frame_evictor_->SwappedFrame(!host_->is_hidden());
1102 1104
1103 // As the metadata update may trigger view invalidation, always call it after 1105 // As the metadata update may trigger view invalidation, always call it after
1104 // any potential compositor scheduling. 1106 // any potential compositor scheduling.
1105 OnFrameMetadataUpdated(metadata); 1107 OnFrameMetadataUpdated(std::move(metadata));
1106 } 1108 }
1107 1109
1108 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame( 1110 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
1109 uint32_t output_surface_id, 1111 uint32_t output_surface_id,
1110 std::unique_ptr<cc::CompositorFrame> frame) { 1112 cc::CompositorFrame frame) {
1111 InternalSwapCompositorFrame(output_surface_id, std::move(frame)); 1113 InternalSwapCompositorFrame(output_surface_id, std::move(frame));
1112 } 1114 }
1113 1115
1114 void RenderWidgetHostViewAndroid::ClearCompositorFrame() { 1116 void RenderWidgetHostViewAndroid::ClearCompositorFrame() {
1115 DestroyDelegatedContent(); 1117 DestroyDelegatedContent();
1116 } 1118 }
1117 1119
1118 void RenderWidgetHostViewAndroid::RetainFrame( 1120 void RenderWidgetHostViewAndroid::RetainFrame(uint32_t output_surface_id,
1119 uint32_t output_surface_id, 1121 cc::CompositorFrame frame) {
1120 std::unique_ptr<cc::CompositorFrame> frame) {
1121 DCHECK(locks_on_frame_count_); 1122 DCHECK(locks_on_frame_count_);
1122 1123
1123 // Store the incoming frame so that it can be swapped when all the locks have 1124 // Store the incoming frame so that it can be swapped when all the locks have
1124 // been released. If there is already a stored frame, then replace and skip 1125 // been released. If there is already a stored frame, then replace and skip
1125 // the previous one but make sure we still eventually send the ACK. Holding 1126 // the previous one but make sure we still eventually send the ACK. Holding
1126 // the ACK also blocks the renderer when its max_frames_pending is reached. 1127 // the ACK also blocks the renderer when its max_frames_pending is reached.
1127 if (last_frame_info_) { 1128 if (last_frame_info_) {
1128 base::Closure ack_callback = 1129 base::Closure ack_callback =
1129 base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck, 1130 base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
1130 weak_ptr_factory_.GetWeakPtr(), 1131 weak_ptr_factory_.GetWeakPtr(),
1131 last_frame_info_->output_surface_id); 1132 last_frame_info_->output_surface_id);
1132 1133
1133 ack_callbacks_.push(ack_callback); 1134 ack_callbacks_.push(ack_callback);
1134 } 1135 }
1135 1136
1136 last_frame_info_.reset( 1137 last_frame_info_.reset(
1137 new LastFrameInfo(output_surface_id, std::move(frame))); 1138 new LastFrameInfo(output_surface_id, std::move(frame)));
1138 } 1139 }
1139 1140
1140 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata( 1141 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
1141 const cc::CompositorFrameMetadata& frame_metadata) { 1142 cc::CompositorFrameMetadata frame_metadata) {
1142 if (!content_view_core_) 1143 if (!content_view_core_)
1143 return; 1144 return;
1144 1145
1145 // This is a subset of OnSwapCompositorFrame() used in the synchronous 1146 // This is a subset of OnSwapCompositorFrame() used in the synchronous
1146 // compositor flow. 1147 // compositor flow.
1147 OnFrameMetadataUpdated(frame_metadata); 1148 OnFrameMetadataUpdated(frame_metadata.Clone());
1148 1149
1149 // DevTools ScreenCast support for Android WebView. 1150 // DevTools ScreenCast support for Android WebView.
1150 WebContents* web_contents = content_view_core_->GetWebContents(); 1151 WebContents* web_contents = content_view_core_->GetWebContents();
1151 if (DevToolsAgentHost::HasFor(web_contents)) { 1152 if (DevToolsAgentHost::HasFor(web_contents)) {
1152 scoped_refptr<DevToolsAgentHost> dtah = 1153 scoped_refptr<DevToolsAgentHost> dtah =
1153 DevToolsAgentHost::GetOrCreateFor(web_contents); 1154 DevToolsAgentHost::GetOrCreateFor(web_contents);
1154 // Unblock the compositor. 1155 // Unblock the compositor.
1155 BrowserThread::PostTask( 1156 BrowserThread::PostTask(
1156 BrowserThread::UI, FROM_HERE, 1157 BrowserThread::UI, FROM_HERE,
1157 base::Bind( 1158 base::Bind(
1158 &RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame, 1159 &RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame,
1159 static_cast<RenderFrameDevToolsAgentHost*>(dtah.get()), 1160 static_cast<RenderFrameDevToolsAgentHost*>(dtah.get()),
1160 frame_metadata)); 1161 base::Passed(&frame_metadata)));
1161 } 1162 }
1162 } 1163 }
1163 1164
1164 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) { 1165 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) {
1165 if (layer_.get()) 1166 if (layer_.get())
1166 layer_->SetContentsOpaque(!enabled); 1167 layer_->SetContentsOpaque(!enabled);
1167 } 1168 }
1168 1169
1169 bool RenderWidgetHostViewAndroid::SupportsAnimation() const { 1170 bool RenderWidgetHostViewAndroid::SupportsAnimation() const {
1170 // The synchronous (WebView) compositor does not have a proper browser 1171 // The synchronous (WebView) compositor does not have a proper browser
(...skipping 850 matching lines...) Expand 10 before | Expand all | Expand 10 after
2021 case ui::MotionEvent::ACTION_UP: 2022 case ui::MotionEvent::ACTION_UP:
2022 case ui::MotionEvent::ACTION_POINTER_UP: 2023 case ui::MotionEvent::ACTION_POINTER_UP:
2023 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.OS.TOUCH_RELEASED", 2024 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.OS.TOUCH_RELEASED",
2024 delta.InMicroseconds(), 1, 1000000, 50); 2025 delta.InMicroseconds(), 1, 1000000, 50);
2025 default: 2026 default:
2026 return; 2027 return;
2027 } 2028 }
2028 } 2029 }
2029 2030
2030 } // namespace content 2031 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698