should be // hidden so that only the element should be visible in , // according to the spec: // https://html.spec.whatwg.org/C/#read-media ShadowRoot& shadow_root = body->EnsureUserAgentShadowRoot(); shadow_root.AppendChild(div_element_); } WillInsertBody(); image_element_ = MakeGarbageCollected(*this); UpdateImageStyle(); image_element_->StartLoadingImageDocument(image_content); body->AppendChild(image_element_.Get()); if (ShouldShrinkToFit()) { // Add event listeners auto* listener = MakeGarbageCollected(this); if (LocalDOMWindow* dom_window = domWindow()) dom_window->addEventListener(event_type_names::kResize, listener, false); if (shrink_to_fit_mode_ == kDesktop) { image_element_->addEventListener(event_type_names::kClick, listener, false); } else if (shrink_to_fit_mode_ == kViewport) { image_element_->addEventListener(event_type_names::kTouchend, listener, false); image_element_->addEventListener(event_type_names::kTouchcancel, listener, false); } } root_element->AppendChild(head); root_element->AppendChild(body); if (IsStopped()) image_element_ = nullptr; } void ImageDocument::UpdateTitle() { // Report the natural image size in the page title, regardless of zoom // level. At a zoom level of 1 the image is guaranteed to have an integer // size. gfx::Size size = ImageSize(); if (!size.width()) return; // Compute the title, we use the decoded filename of the resource, falling // back on the (decoded) hostname if there is no path. String file_name = DecodeUrlEscapeSequences(Url().LastPathComponent(), DecodeUrlMode::kUtf8OrIsomorphic); if (file_name.empty()) { file_name = Url().Host().ToString(); } setTitle(ImageTitle(file_name, size)); } float ImageDocument::Scale() const { DCHECK_EQ(shrink_to_fit_mode_, kDesktop); if (!image_element_ || image_element_->GetDocument() != this) return 1.0f; LocalFrameView* view = GetFrame()->View(); if (!view) return 1.0f; gfx::Size image_size = ImageSize(); if (image_size.IsEmpty()) return 1.0f; // We want to pretend the viewport is larger when the user has zoomed the // page in (but not when the zoom is coming from device scale). const float viewport_zoom = view->GetChromeClient()->WindowToViewportScalar(GetFrame(), 1.f); float width_scale = view->Width() / (viewport_zoom * image_size.width()); float height_scale = view->Height() / (viewport_zoom * image_size.height()); return std::min(width_scale, height_scale); } void ImageDocument::ResizeImageToFit() { DCHECK_EQ(shrink_to_fit_mode_, kDesktop); if (!image_element_ || image_element_->GetDocument() != this) return; gfx::Size image_size = gfx::ScaleToFlooredSize(ImageSize(), Scale()); image_element_->setWidth(image_size.width()); image_element_->setHeight(image_size.height()); UpdateImageStyle(); } void ImageDocument::ImageClicked(int x, int y) { DCHECK_EQ(shrink_to_fit_mode_, kDesktop); if (!image_size_is_known_ || ImageFitsInWindow()) return; should_shrink_image_ = !should_shrink_image_; if (should_shrink_image_) { WindowSizeChanged(); } else { // Adjust the coordinates to account for the fact that the image was // centered on the screen. float image_x = x - image_element_->OffsetLeft(); float image_y = y - image_element_->OffsetTop(); RestoreImageSize(); UpdateStyleAndLayout(DocumentUpdateReason::kInput); double scale = Scale(); double device_scale_factor = GetFrame()->View()->GetChromeClient()->WindowToViewportScalar( GetFrame(), 1.f); float scroll_x = (image_x * device_scale_factor) / scale - static_cast(GetFrame()->View()->Width()) / 2; float scroll_y = (image_y * device_scale_factor) / scale - static_cast(GetFrame()->View()->Height()) / 2; GetFrame()->View()->LayoutViewport()->SetScrollOffset( ScrollOffset(scroll_x, scroll_y), mojom::blink::ScrollType::kProgrammatic, cc::ScrollSourceType::kStationaryScroll); } } void ImageDocument::ImageLoaded() { image_is_loaded_ = true; UpdateImageStyle(); } ImageDocument::MouseCursorMode ImageDocument::ComputeMouseCursorMode() const { if (!image_is_loaded_) return kDefault; if (shrink_to_fit_mode_ != kDesktop || !ShouldShrinkToFit()) return kDefault; if (ImageFitsInWindow()) return kDefault; return should_shrink_image_ ? kZoomIn : kZoomOut; } void ImageDocument::UpdateImageStyle() { StringBuilder image_style; image_style.Append("display: block;"); image_style.Append("-webkit-user-select: none;"); if (ShouldShrinkToFit()) { if (shrink_to_fit_mode_ == kViewport) image_style.Append("max-width: 100%;"); image_style.Append("margin: auto;"); } MouseCursorMode cursor_mode = ComputeMouseCursorMode(); if (cursor_mode == kZoomIn) image_style.Append("cursor: zoom-in;"); else if (cursor_mode == kZoomOut) image_style.Append("cursor: zoom-out;"); if (GetFrame()->IsOutermostMainFrame()) { if (image_is_loaded_) { image_style.Append("background-color: hsl(0, 0%, 90%);"); DCHECK(image_element_); DCHECK(image_element_->CachedImage()); if (!image_element_->CachedImage()->IsAnimatedImage()) { image_style.Append("transition: background-color 300ms;"); } } else if (image_size_is_known_) { image_style.Append("background-color: hsl(0, 0%, 25%);"); } } image_element_->setAttribute(html_names::kStyleAttr, image_style.ToAtomicString()); } void ImageDocument::ImageUpdated() { DCHECK(image_element_); if (image_size_is_known_) return; UpdateStyleAndLayoutTree(); if (!image_element_->CachedImage() || ImageSize().IsEmpty()) return; image_size_is_known_ = true; UpdateImageStyle(); if (ShouldShrinkToFit()) { // Force resizing of the image WindowSizeChanged(); } } void ImageDocument::RestoreImageSize() { DCHECK_EQ(shrink_to_fit_mode_, kDesktop); if (!image_element_ || !image_size_is_known_ || image_element_->GetDocument() != this) return; gfx::Size image_size = ImageSize(); image_element_->setWidth(image_size.width()); image_element_->setHeight(image_size.height()); UpdateImageStyle(); did_shrink_image_ = false; } bool ImageDocument::ImageFitsInWindow() const { DCHECK_EQ(shrink_to_fit_mode_, kDesktop); return Scale() >= 1; } int ImageDocument::CalculateDivWidth() { // Zooming in and out of an image being displayed within a viewport is done // by changing the page scale factor of the page instead of changing the // size of the image. The size of the image is set so that: // * Images wider than the viewport take the full width of the screen. // * Images taller than the viewport are initially aligned with the top of // of the frame. // * Images smaller in either dimension are centered along that axis. int width = (RuntimeEnabledFeatures::ImageDocumentUseLayoutWidthEnabled() ? View()->GetLayoutSize().width() : GetFrame()->GetPage()->GetVisualViewport().Size().width()) / GetFrame()->LayoutZoomFactor(); // For huge images, minimum-scale=0.1 is still too big on small screens. // Set the

width so that the image will shrink to fit the width of the // screen when the scale is minimum. int max_width = std::min(ImageSize().width(), width * 10); return std::max(width, max_width); } void ImageDocument::WindowSizeChanged() { if (!image_element_ || !image_size_is_known_ || image_element_->GetDocument() != this || // Frame view can be empty on Android where image_size is set before the // Android view completes a layout pass. Avoid processing in this case. GetFrame()->View()->Size().IsEmpty()) { return; } if (shrink_to_fit_mode_ == kViewport) { int div_width = CalculateDivWidth(); div_element_->SetInlineStyleProperty(CSSPropertyID::kWidth, div_width, CSSPrimitiveValue::UnitType::kPixels); // Explicitly set the height of the

containing the so that it // can display the full image without shrinking it, allowing a full-width // reading mode for normal-width-huge-height images. Use the LayoutSize // for height rather than viewport since that doesn't change based on the // URL bar coming in and out - thus preventing the image from jumping // around. i.e. The div should fill the viewport when minimally zoomed and // the URL bar is showing, but won't fill the new space when the URL bar // hides. gfx::Size layout_size = View()->GetLayoutSize(); float aspect_ratio = static_cast(layout_size.width()) / layout_size.height(); int div_height = std::max(ImageSize().height(), static_cast(div_width / aspect_ratio)); div_element_->SetInlineStyleProperty(CSSPropertyID::kHeight, div_height, CSSPrimitiveValue::UnitType::kPixels); return; } bool fits_in_window = ImageFitsInWindow(); // If the image has been explicitly zoomed in, restore the cursor if the image // fits and set it to a zoom out cursor if the image doesn't fit if (!should_shrink_image_) { UpdateImageStyle(); return; } if (did_shrink_image_) { // If the window has been resized so that the image fits, restore the image // size otherwise update the restored image size. if (fits_in_window) RestoreImageSize(); else ResizeImageToFit(); } else { // If the image isn't resized but needs to be, then resize it. if (!fits_in_window) { ResizeImageToFit(); did_shrink_image_ = true; } } } ImageResourceContent* ImageDocument::CachedImage() { if (!image_element_) return nullptr; return image_element_->CachedImage(); } bool ImageDocument::ShouldShrinkToFit() const { // WebView automatically resizes to match the contents, causing an infinite // loop as the contents then resize to match the window. To prevent this, // disallow images from shrinking to fit for WebViews. bool is_wrap_content_web_view = GetPage() && GetPage()->GetSettings().GetForceZeroLayoutHeight(); return GetFrame()->IsOutermostMainFrame() && !is_wrap_content_web_view; } void ImageDocument::Trace(Visitor* visitor) const { visitor->Trace(div_element_); visitor->Trace(image_element_); HTMLDocument::Trace(visitor); } // -------- void ImageEventListener::Invoke(ExecutionContext*, Event* event) { auto* mouse_event = DynamicTo(event); if (event->type() == event_type_names::kResize) { doc_->WindowSizeChanged(); } else if (event->type() == event_type_names::kClick && mouse_event) { doc_->ImageClicked(mouse_event->x(), mouse_event->y()); } else if ((event->type() == event_type_names::kTouchend || event->type() == event_type_names::kTouchcancel) && IsA(event)) { doc_->UpdateImageStyle(); } } bool ImageEventListener::Matches(const EventListener& listener) const { if (const ImageEventListener* image_event_listener = DynamicTo(listener)) { return doc_ == image_event_listener->doc_; } return false; } } // namespace blink