Consolidate how ImageDocument sets image styling

third_party/WebKit/Source/core/html/ImageDocument.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 183 matching lines @@
 // --------
 
 ImageDocument::ImageDocument(const DocumentInit& initializer)
     : HTMLDocument(initializer, ImageDocumentClass),
       m_divElement(nullptr),
       m_imageElement(nullptr),
       m_imageSizeIsKnown(false),
       m_didShrinkImage(false),
       m_shouldShrinkImage(shouldShrinkToFit()),
       m_imageIsLoaded(false),
-      m_checkerSize(0),
+      m_styleCheckerSize(0),
+      m_styleMouseCursorMode(Default),
       m_shrinkToFitMode(frame()->settings()->viewportEnabled() ? Viewport
                                                                : Desktop) {
   setCompatibilityMode(QuirksMode);
   lockCompatibilityMode();
   UseCounter::count(*this, UseCounter::ImageDocument);
   if (!isInMainFrame())
     UseCounter::count(*this, UseCounter::ImageDocumentInFrame);
 }
 
 DocumentParser* ImageDocument::createParser() {
@@ skipping 103 matching lines @@
   DCHECK_EQ(m_shrinkToFitMode, Desktop);
   if (!m_imageElement || m_imageElement->document() != this)
     return;
 
   LayoutSize imageSize = cachedImageSize(m_imageElement);
 
   const float scale = this->scale();
   m_imageElement->setWidth(static_cast<int>(imageSize.width() * scale));
   m_imageElement->setHeight(static_cast<int>(imageSize.height() * scale));
 
-  m_imageElement->setInlineStyleProperty(CSSPropertyCursor, CSSValueZoomIn);
+  updateImageStyle();
 }
 
 void ImageDocument::imageClicked(int x, int y) {
   DCHECK_EQ(m_shrinkToFitMode, Desktop);
 
   if (!m_imageSizeIsKnown || imageFitsInWindow())
     return;
 
   m_shouldShrinkImage = !m_shouldShrinkImage;
 
@@ skipping 35 matching lines @@
   imageStyle.append("-webkit-user-select: none;");
 
   if (shouldShrinkToFit()) {
     if (m_shrinkToFitMode == Viewport)
       imageStyle.append("max-width: 100%;");
 
     // Once the image has fully loaded, it is displayed atop a checkerboard to
     // show transparency more faithfully.  The pattern is generated via CSS.
     if (m_imageIsLoaded) {
       int newCheckerSize = kBaseCheckerSize;
+      MouseCursorMode newCursorMode = Default;
 
       if (m_shrinkToFitMode == Viewport) {
         double scale;
 
         if (hasFinishedParsing()) {
           // To ensure the checker pattern is visible for large images, the
           // checker size is dynamically adjusted to account for how much the
           // page is currently being scaled.
           scale = frame()->host()->visualViewport().scale();
         } else {
           // The checker pattern is initialized based on how large the image is
           // relative to the viewport.
           int viewportWidth = frame()->host()->visualViewport().size().width();
           scale = viewportWidth / static_cast<double>(calculateDivWidth());
         }
 
         newCheckerSize = round(std::max(1.0, newCheckerSize / scale));
+      } else {
+        // In desktop mode, the user can click on the image to zoom in or out.
+        DCHECK_EQ(m_shrinkToFitMode, Desktop);
+        if (imageFitsInWindow()) {
+          newCursorMode = Default;
+        } else {
+          newCursorMode = m_shouldShrinkImage ? ZoomIn : ZoomOut;
+        }
       }
 
-      // The only thing that can differ between updates is the checker size.
-      if (newCheckerSize == m_checkerSize)
+      // The only things that can differ between updates are checker size and
+      // the type of cursor being displayed.
+      if (newCheckerSize == m_styleCheckerSize &&
+          newCursorMode == m_styleMouseCursorMode) {
         return;
-      m_checkerSize = newCheckerSize;
+      }
+      m_styleCheckerSize = newCheckerSize;
+      m_styleMouseCursorMode = newCursorMode;
 
       imageStyle.append("background-position: 0px 0px, ");
-      imageStyle.append(AtomicString::number(m_checkerSize));
+      imageStyle.append(AtomicString::number(m_styleCheckerSize));
       imageStyle.append("px ");
-      imageStyle.append(AtomicString::number(m_checkerSize));
+      imageStyle.append(AtomicString::number(m_styleCheckerSize));
       imageStyle.append("px;");
 
-      int tileSize = m_checkerSize * 2;
+      int tileSize = m_styleCheckerSize * 2;
       imageStyle.append("background-size: ");
       imageStyle.append(AtomicString::number(tileSize));
       imageStyle.append("px ");
       imageStyle.append(AtomicString::number(tileSize));
       imageStyle.append("px;");
 
       // Generating the checkerboard pattern this way is not exactly cheap.
       // If rasterization performance becomes an issue, we could look at using
       // a cheaper shader (e.g. pre-generate a scaled tile + base64-encode +
       // inline dataURI => single bitmap shader).
       imageStyle.append(
           "background-image:"
           "linear-gradient(45deg, #eee 25%, transparent 25%, transparent 75%, "
           "#eee 75%, #eee 100%),"
           "linear-gradient(45deg, #eee 25%, white 25%, white 75%, "
           "#eee 75%, #eee 100%);");
+
+      if (m_shrinkToFitMode == Desktop) {
+        if (m_styleMouseCursorMode == ZoomIn)
+          imageStyle.append("cursor: zoom-in;");
+        else if (m_styleMouseCursorMode == ZoomOut)
+          imageStyle.append("cursor: zoom-out;");
+      }
     }
   }
 
   m_imageElement->setAttribute(styleAttr, imageStyle.toAtomicString());
 }
 
 void ImageDocument::imageUpdated() {
   DCHECK(m_imageElement);
 
   if (m_imageSizeIsKnown)
@@ skipping 20 matching lines @@
   DCHECK_EQ(m_shrinkToFitMode, Desktop);
 
   if (!m_imageElement || !m_imageSizeIsKnown ||
       m_imageElement->document() != this)
     return;
 
   DCHECK(m_imageElement->cachedImage());
   LayoutSize imageSize = cachedImageSize(m_imageElement);
   m_imageElement->setWidth(imageSize.width().toInt());
   m_imageElement->setHeight(imageSize.height().toInt());
-
-  if (imageFitsInWindow())
-    m_imageElement->removeInlineStyleProperty(CSSPropertyCursor);
-  else
-    m_imageElement->setInlineStyleProperty(CSSPropertyCursor, CSSValueZoomOut);
+  updateImageStyle();
 
   m_didShrinkImage = false;
 }
 
 bool ImageDocument::imageFitsInWindow() const {
   DCHECK_EQ(m_shrinkToFitMode, Desktop);
   return this->scale() >= 1;
 }
 
 int ImageDocument::calculateDivWidth() {
@@ skipping 35 matching lines @@
     m_divElement->setInlineStyleProperty(CSSPropertyHeight, divHeight,
                                          CSSPrimitiveValue::UnitType::Pixels);
     return;
   }
 
   bool fitsInWindow = 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 (!m_shouldShrinkImage) {
-    if (fitsInWindow)
-      m_imageElement->removeInlineStyleProperty(CSSPropertyCursor);
-    else
-      m_imageElement->setInlineStyleProperty(CSSPropertyCursor,
-                                             CSSValueZoomOut);
+    updateImageStyle();
     return;
   }
 
   if (m_didShrinkImage) {
     // If the window has been resized so that the image fits, restore the image
     // size otherwise update the restored image size.
     if (fitsInWindow)
       restoreImageSize();
     else
       resizeImageToFit();
@@ skipping 44 matching lines @@
 }
 
 bool ImageEventListener::operator==(const EventListener& listener) const {
   if (const ImageEventListener* imageEventListener =
           ImageEventListener::cast(&listener))
     return m_doc == imageEventListener->m_doc;
   return false;
 }
 
 }  // namespace blink