callback.Run(result, *bitmap);
}
-bool UsingDelegatedRenderer() {
- bool using_delegated_renderer = false;
-
- using_delegated_renderer |= CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kEnableDelegatedRenderer);
-
- using_delegated_renderer &= !CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kDisableDelegatedRenderer);
-
- return using_delegated_renderer;
-}
-
-ui::LatencyInfo CreateLatencyInfo(const blink::WebInputEvent event) {
+ui::LatencyInfo CreateLatencyInfo(const blink::WebInputEvent& event) {
ui::LatencyInfo latency_info;
// The latency number should only be added if the timestamp is valid.
if (event.timeStampSeconds) {
ContentViewCoreImpl* content_view_core)
: host_(widget_host),
needs_begin_frame_(false),
- are_layers_attached_(!widget_host->is_hidden()),
+ is_showing_(!widget_host->is_hidden()),
content_view_core_(NULL),
ime_adapter_android_(this),
cached_background_color_(SK_ColorWHITE),
using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
widget_host->GetProcess()->GetID(),
widget_host->GetRoutingID()) != NULL),
- frame_evictor_(new DelegatedFrameEvictor(this)) {
- if (!UsingDelegatedRenderer()) {
+ frame_evictor_(new DelegatedFrameEvictor(this)),
+ using_delegated_renderer_(CommandLine::ForCurrentProcess()->HasSwitch(
+ switches::kEnableDelegatedRenderer) &&
+ !CommandLine::ForCurrentProcess()->HasSwitch(
+ switches::kDisableDelegatedRenderer)) {
+ if (!using_delegated_renderer_) {
texture_layer_ = cc::TextureLayer::Create(NULL);
layer_ = texture_layer_;
}
SetSize(rect.size());
}
-blink::WebGLId RenderWidgetHostViewAndroid::GetScaledContentTexture(
+void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
float scale,
- gfx::Size* out_size) {
- gfx::Size size(gfx::ToCeiledSize(
- gfx::ScaleSize(texture_size_in_layer_, scale)));
-
- if (!CompositorImpl::IsInitialized() ||
- texture_id_in_layer_ == 0 ||
- texture_size_in_layer_.IsEmpty() ||
- size.IsEmpty()) {
- if (out_size)
- out_size->SetSize(0, 0);
-
- return 0;
+ gfx::Size* out_size,
+ const base::Callback<void(bool, const SkBitmap&)>& result_callback) {
+ if (!IsSurfaceAvailableForCopy()) {
+ result_callback.Run(false, SkBitmap());
+ return;
}
- if (out_size)
- *out_size = size;
-
- GLHelper* helper = ImageTransportFactoryAndroid::GetInstance()->GetGLHelper();
- return helper->CopyAndScaleTexture(texture_id_in_layer_,
- texture_size_in_layer_,
- size,
- true,
- GLHelper::SCALER_QUALITY_FAST);
+ gfx::Size bounds = layer_->bounds();
+ gfx::Rect src_subrect(bounds);
+ const gfx::Display& display =
+ gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+ float device_scale_factor = display.device_scale_factor();
+ DCHECK_GT(device_scale_factor, 0);
+ gfx::Size dst_size(
+ gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale / device_scale_factor)));
+ *out_size = dst_size;
+ CopyFromCompositingSurface(
+ src_subrect, dst_size, result_callback, SkBitmap::kARGB_8888_Config);
}
bool RenderWidgetHostViewAndroid::PopulateBitmapWithContents(jobject jbitmap) {
bool RenderWidgetHostViewAndroid::HasValidFrame() const {
if (!content_view_core_)
return false;
+ if (!layer_)
+ return false;
+
if (texture_size_in_layer_.IsEmpty())
return false;
- if (UsingDelegatedRenderer()) {
+ if (using_delegated_renderer_) {
if (!delegated_renderer_layer_.get())
return false;
} else {
}
void RenderWidgetHostViewAndroid::Show() {
- if (are_layers_attached_)
+ if (is_showing_)
return;
- are_layers_attached_ = true;
- AttachLayers();
+ is_showing_ = true;
+ if (layer_)
+ layer_->SetHideLayerAndSubtree(false);
frame_evictor_->SetVisible(true);
WasShown();
}
void RenderWidgetHostViewAndroid::Hide() {
- if (!are_layers_attached_)
+ if (!is_showing_)
return;
- are_layers_attached_ = false;
- RemoveLayers();
+ is_showing_ = false;
+ if (layer_)
+ layer_->SetHideLayerAndSubtree(true);
frame_evictor_->SetVisible(false);
WasHidden();
// ContentViewCoreImpl represents the native side of the Java
// ContentViewCore. It being NULL means that it is not attached
// to the View system yet, so we treat this RWHVA as hidden.
- return are_layers_attached_ && content_view_core_;
+ return is_showing_ && content_view_core_;
}
void RenderWidgetHostViewAndroid::LockResources() {
const gfx::Display& display =
gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
float device_scale_factor = display.device_scale_factor();
-
- DCHECK_EQ(device_scale_factor,
- ui::GetImageScale(GetScaleFactorForView(this)));
-
- const gfx::Size& dst_size_in_pixel = ConvertViewSizeToPixel(this, dst_size);
+ gfx::Size dst_size_in_pixel =
+ ConvertRectToPixel(device_scale_factor, gfx::Rect(dst_size)).size();
gfx::Rect src_subrect_in_pixel =
ConvertRectToPixel(device_scale_factor, src_subrect);
if (using_synchronous_compositor_) {
- SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback);
+ SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback,
+ bitmap_config);
UMA_HISTOGRAM_TIMES("Compositing.CopyFromSurfaceTimeSynchronous",
base::TimeTicks::Now() - start_time);
return;
}
scoped_ptr<cc::CopyOutputRequest> request;
- if (src_subrect_in_pixel.size() == dst_size_in_pixel) {
+ if ((src_subrect_in_pixel.size() == dst_size_in_pixel) &&
+ (bitmap_config == SkBitmap::kARGB_8888_Config)) {
request = cc::CopyOutputRequest::CreateBitmapRequest(base::Bind(
&RenderWidgetHostViewAndroid::PrepareBitmapCopyOutputResult,
dst_size_in_pixel,
+ bitmap_config,
start_time,
callback));
} else {
ack);
}
+void RenderWidgetHostViewAndroid::SendReturnedDelegatedResources(
+ uint32 output_surface_id) {
+ DCHECK(resource_collection_);
+
+ cc::CompositorFrameAck ack;
+ resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
+ DCHECK(!ack.resources.empty());
+
+ RenderWidgetHostImpl::SendReclaimCompositorResources(
+ host_->GetRoutingID(),
+ output_surface_id,
+ host_->GetProcess()->GetID(),
+ ack);
+}
+
void RenderWidgetHostViewAndroid::UnusedResourcesAreAvailable() {
- // TODO(danakj): If no ack is pending, collect and send resources now.
+ if (ack_callbacks_.size())
+ return;
+ SendReturnedDelegatedResources(last_output_surface_id_);
}
void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
- if (are_layers_attached_)
- RemoveLayers();
+ RemoveLayers();
frame_provider_ = NULL;
delegated_renderer_layer_ = NULL;
layer_ = NULL;
bool has_content = !texture_size_in_layer_.IsEmpty();
if (output_surface_id != last_output_surface_id_) {
- // TODO(danakj): Lose all resources and send them back here, such as:
- // resource_collection_->LoseAllResources();
- // SendReturnedDelegatedResources(last_output_surface_id_);
-
// Drop the cc::DelegatedFrameResourceCollection so that we will not return
// any resources from the old output surface with the new output surface id.
if (resource_collection_.get()) {
+ if (resource_collection_->LoseAllResources())
+ SendReturnedDelegatedResources(last_output_surface_id_);
+
resource_collection_->SetClient(NULL);
resource_collection_ = NULL;
}
}
if (!frame_provider_ ||
texture_size_in_layer_ != frame_provider_->frame_size()) {
- if (are_layers_attached_)
- RemoveLayers();
+ RemoveLayers();
frame_provider_ = new cc::DelegatedFrameProvider(
resource_collection_.get(), frame_data.Pass());
delegated_renderer_layer_ =
cc::DelegatedRendererLayer::Create(frame_provider_);
layer_ = delegated_renderer_layer_;
- if (are_layers_attached_)
- AttachLayers();
+ AttachLayers();
} else {
frame_provider_->SetFrameData(frame_data.Pass());
}
// to schedule a Draw immediately when it sees the texture layer invalidation.
UpdateContentViewCoreFrameMetadata(frame->metadata);
+ if (layer_ && layer_->layer_tree_host()) {
+ for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
+ scoped_ptr<cc::SwapPromise> swap_promise(
+ new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
+ layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
+ }
+ }
+
if (frame->delegated_frame_data) {
- DCHECK(UsingDelegatedRenderer());
+ DCHECK(using_delegated_renderer_);
DCHECK(frame->delegated_frame_data);
DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
ComputeContentsSize(frame->metadata);
SwapDelegatedFrame(output_surface_id, frame->delegated_frame_data.Pass());
+ frame_evictor_->SwappedFrame(!host_->is_hidden());
return;
}
- DCHECK(!UsingDelegatedRenderer());
+ DCHECK(!using_delegated_renderer_);
if (!frame->gl_frame_data || frame->gl_frame_data->mailbox.IsZero())
return;
texture_size_in_layer_ = frame->gl_frame_data->size;
ComputeContentsSize(frame->metadata);
- if (layer_->layer_tree_host()) {
- for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
- scoped_ptr<cc::SwapPromise> swap_promise(
- new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
- layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
- }
- }
-
BuffersSwapped(frame->gl_frame_data->mailbox, output_surface_id, callback);
frame_evictor_->SwappedFrame(!host_->is_hidden());
}
void RenderWidgetHostViewAndroid::SynchronousCopyContents(
const gfx::Rect& src_subrect_in_pixel,
const gfx::Size& dst_size_in_pixel,
- const base::Callback<void(bool, const SkBitmap&)>& callback) {
+ const base::Callback<void(bool, const SkBitmap&)>& callback,
+ const SkBitmap::Config config) {
SynchronousCompositor* compositor =
SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
host_->GetRoutingID());
}
SkBitmap bitmap;
- bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+ bitmap.setConfig(config,
dst_size_in_pixel.width(),
dst_size_in_pixel.height());
bitmap.allocPixels();
content_view_core_->AttachLayer(layer_);
if (overscroll_effect_enabled_)
overscroll_effect_->Enable();
+ layer_->SetHideLayerAndSubtree(!is_showing_);
}
void RenderWidgetHostViewAndroid::RemoveLayers() {
}
void RenderWidgetHostViewAndroid::GestureEventAck(
- int gesture_event_type,
+ const blink::WebGestureEvent& event,
InputEventAckState ack_result) {
- // Scroll events.
- if (gesture_event_type == blink::WebInputEvent::GestureScrollBegin) {
- content_view_core_->OnScrollBeginEventAck();
- }
- if (gesture_event_type == blink::WebInputEvent::GestureScrollUpdate &&
- ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) {
- content_view_core_->OnScrollUpdateGestureConsumed();
- }
- if (gesture_event_type == blink::WebInputEvent::GestureScrollEnd) {
- content_view_core_->OnScrollEndEventAck();
- }
-
- // Fling events.
- if (gesture_event_type == blink::WebInputEvent::GestureFlingStart) {
- content_view_core_->OnFlingStartEventAck(ack_result);
- }
+ if (content_view_core_)
+ content_view_core_->OnGestureEventAck(event, ack_result);
}
InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent(
const blink::WebInputEvent& input_event) {
+ if (content_view_core_ &&
+ content_view_core_->FilterInputEvent(input_event))
+ return INPUT_EVENT_ACK_STATE_CONSUMED;
+
if (!host_)
return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
void RenderWidgetHostViewAndroid::OnSetNeedsFlushInput() {
if (flush_input_requested_ || !content_view_core_)
return;
+ TRACE_EVENT0("input", "RenderWidgetHostViewAndroid::OnSetNeedsFlushInput");
flush_input_requested_ = true;
content_view_core_->AddBeginFrameSubscriber();
}
host_->ForwardTouchEventWithLatencyInfo(event, CreateLatencyInfo(event));
}
-
void RenderWidgetHostViewAndroid::SendMouseEvent(
const blink::WebMouseEvent& event) {
if (host_)
void RenderWidgetHostViewAndroid::OnOverscrolled(
gfx::Vector2dF accumulated_overscroll,
gfx::Vector2dF current_fling_velocity) {
- if (!content_view_core_ || !are_layers_attached_)
+ if (!content_view_core_ || !layer_ || !is_showing_)
return;
if (overscroll_effect_->OnOverscrolled(content_view_core_->GetLayer(),
ContentViewCoreImpl* content_view_core) {
RunAckCallbacks();
- if (are_layers_attached_)
- RemoveLayers();
-
+ RemoveLayers();
if (content_view_core_ && !using_synchronous_compositor_)
content_view_core_->GetWindowAndroid()->RemoveObserver(this);
SetContentViewCore(obj);
}
- if (are_layers_attached_) {
- AttachLayers();
- if (content_view_core_ && !using_synchronous_compositor_)
- content_view_core_->GetWindowAndroid()->AddObserver(this);
- }
-
- // Ensure ContentsViewCore is aware of the current touch handling state, eg.
- // in case we've already been running JS for the page as part of preload.
- if (content_view_core_ && host_)
- content_view_core_->HasTouchEventHandlers(host_->has_touch_handler());
+ AttachLayers();
+ if (content_view_core_ && !using_synchronous_compositor_)
+ content_view_core_->GetWindowAndroid()->AddObserver(this);
}
void RenderWidgetHostViewAndroid::RunAckCallbacks() {
}
}
-void RenderWidgetHostViewAndroid::HasTouchEventHandlers(
- bool need_touch_events) {
- if (content_view_core_)
- content_view_core_->HasTouchEventHandlers(need_touch_events);
-}
-
void RenderWidgetHostViewAndroid::OnCompositingDidCommit() {
RunAckCallbacks();
}
const base::TimeTicks& start_time,
const base::Callback<void(bool, const SkBitmap&)>& callback,
scoped_ptr<cc::CopyOutputResult> result) {
- DCHECK(result->HasTexture());
base::ScopedClosureRunner scoped_callback_runner(
base::Bind(callback, false, SkBitmap()));
ignore_result(scoped_callback_runner.Release());
gl_helper->CropScaleReadbackAndCleanMailbox(
- texture_mailbox.name(),
+ texture_mailbox.mailbox(),
texture_mailbox.sync_point(),
result->size(),
gfx::Rect(result->size()),
// static
void RenderWidgetHostViewAndroid::PrepareBitmapCopyOutputResult(
const gfx::Size& dst_size_in_pixel,
+ const SkBitmap::Config config,
const base::TimeTicks& start_time,
const base::Callback<void(bool, const SkBitmap&)>& callback,
scoped_ptr<cc::CopyOutputResult> result) {
+ if (config != SkBitmap::kARGB_8888_Config) {
+ NOTIMPLEMENTED();
+ callback.Run(false, SkBitmap());
+ return;
+ }
DCHECK(result->HasBitmap());
base::ScopedClosureRunner scoped_callback_runner(
base::Bind(callback, false, SkBitmap()));
projects / platform / framework / web / crosswalk.git / blobdiff