Compute pageScaleFactor on page so that fixed layout page fits width of window.

content/renderer/render_view.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 244 matching lines @@
 // current content state during tab closing we use a shorter timeout for the
 // foreground renderer. This means there is a small window of time from which
 // content state is modified and not sent to session restore, but this is
 // better than having to wake up all renderers during shutdown.
 static const int kDelaySecondsForContentStateSyncHidden = 5;
 static const int kDelaySecondsForContentStateSync = 1;
 
 // The maximum number of popups that can be spawned from one page.
 static const int kMaximumNumberOfUnacknowledgedPopups = 25;
 
+// The default layout width and height for pages when fixed layout is enabled.
+static const int kDefaultLayoutWidth = 980;
+static const int kDefaultLayoutHeight = 640;
+
 static const float kScalingIncrement = 0.1f;
 
 static void GetRedirectChain(WebDataSource* ds, std::vector<GURL>* result) {
   WebVector<WebURL> urls;
   ds->redirectChain(urls);
   result->reserve(urls.size());
   for (size_t i = 0; i < urls.size(); ++i)
     result->push_back(urls[i]);
 }
 
@@ skipping 85 matching lines @@
       cached_has_main_frame_vertical_scrollbar_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(accessibility_method_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
       geolocation_dispatcher_(NULL),
       speech_input_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
       accessibility_ack_pending_(false),
       p2p_socket_dispatcher_(NULL),
       devtools_agent_(NULL),
+      user_scalable_(true),
+      minimum_scale_(content::kMinPageScaleFactor),
+      maximum_scale_(content::kMaxPageScaleFactor),
       session_storage_namespace_id_(session_storage_namespace_id),
       handling_select_range_(false) {
   routing_id_ = routing_id;
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
   webwidget_ = WebView::create(this);
 
   if (counter) {
     shared_popup_counter_ = counter;
@@ skipping 839 matching lines @@
   // If we end up reusing this WebRequest (for example, due to a #ref click),
   // we don't want the transition type to persist.  Just clear it.
   navigation_state->set_transition_type(PageTransition::LINK);
 
   // Check if the navigation was within the same page, in which case we don't
   // want to clear the accessibility cache.
   if (accessibility_.get() && !navigation_state->was_within_same_page()) {
     accessibility_.reset();
     pending_accessibility_notifications_.clear();
   }
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kEnableFixedLayout)) {
+    // Only enable fixed layout for normal web content.
+    GURL frame_url = GURL(request.url());
+    if (frame_url.SchemeIs(chrome::kHttpScheme) ||
+        frame_url.SchemeIs(chrome::kHttpsScheme)) {

[jamesr, 2011/09/02 17:43:09]

I really doubt this is the best way to test for web content, what about
extension pages or file:// URLs?

[Fady Samuel, 2011/09/08 23:46:39]

This is intentional. WebUI is broken with fixed layout currently. Fixing this
will take a while so this "hack" is in place until (if) we decide to fix WebUI.

[jamesr, 2011/09/09 00:11:40]

Good grief!  That is horrible.  What is wrong with WebUI?  Is it the actual
content of WebUI pages that is broken (as in the html/css we use on these pages)
or something else?  If it is just the html/css can't you fix it by proper use of
viewport tags?

If you really want to exclude WebUI, then do it by checking for the WebUI scheme
explicitly, file a bug, and reference the bug in a comment.  This code also
breaks chrome extension pages, file:// urls, etc etc.

I'm having serious doubts about this codepath if it can't handle WebUI....

+      webview()->enableFixedLayoutMode(true);
+      webview()->setFixedLayoutSize(
+          WebSize(kDefaultLayoutWidth, kDefaultLayoutHeight));
+    }
+  }
 }
 
 // Tell the embedding application that the title of the active page has changed
 void RenderView::UpdateTitle(WebFrame* frame,
                              const string16& title,
                              WebTextDirection title_direction) {
   // Ignore all but top level navigations.
   if (frame->parent())
     return;
 
@@ skipping 192 matching lines @@
 
 WebExternalPopupMenu* RenderView::createExternalPopupMenu(
     const WebPopupMenuInfo& popup_menu_info,
     WebExternalPopupMenuClient* popup_menu_client) {
   DCHECK(!external_popup_menu_.get());
   external_popup_menu_.reset(
       new ExternalPopupMenu(this, popup_menu_info, popup_menu_client));
   return external_popup_menu_.get();
 }
 
+WebRect RenderView::getDeviceRect() const {
+  return WebRect(0, 0, size().width(), size().height());
+}
+
 RenderWidgetFullscreenPepper* RenderView::CreatePepperFullscreenContainer(
     webkit::ppapi::PluginInstance* plugin) {
   GURL active_url;
   if (webview() && webview()->mainFrame())
     active_url = GURL(webview()->mainFrame()->document().url());
   RenderWidgetFullscreenPepper* widget = RenderWidgetFullscreenPepper::Create(
       routing_id_, render_thread_, plugin, active_url);
   widget->show(WebKit::WebNavigationPolicyIgnore);
   return widget;
 }
@@ skipping 1054 matching lines @@
     page_id_ = next_page_id_++;
 
     // Advance our offset in session history, applying the length limit.  There
     // is now no forward history.
     history_list_offset_++;
     if (history_list_offset_ >= content::kMaxSessionHistoryEntries)
       history_list_offset_ = content::kMaxSessionHistoryEntries - 1;
     history_list_length_ = history_list_offset_ + 1;
     history_page_ids_.resize(history_list_length_, -1);
     history_page_ids_[history_list_offset_] = page_id_;
+
+    // Prepare for initialization to overview when content size becomes
+    // available.
+    page_scale_factor_set_ = false;
   } else {
     // Inspect the navigation_state on this frame to see if the navigation
     // corresponds to a session history navigation...  Note: |frame| may or
     // may not be the toplevel frame, but for the case of capturing session
     // history, the first committed frame suffices.  We keep track of whether
     // we've seen this commit before so that only capture session history once
     // per navigation.
     //
     // Note that we need to check if the page ID changed. In the case of a
     // reload, the page ID doesn't change, and UpdateSessionHistory gets the
@@ skipping 301 matching lines @@
   content::GetContentClient()->renderer()->DidDestroyScriptContext(frame);
 }
 
 void RenderView::didCreateIsolatedScriptContext(
     WebFrame* frame, int world_id, v8::Handle<v8::Context> context) {
   content::GetContentClient()->renderer()->DidCreateIsolatedScriptContext(
       frame, world_id, context);
 }
 
 void RenderView::didUpdateLayout(WebFrame* frame) {
+  if (webview() && webview()->isFixedLayoutModeEnabled() &&
+      webview()->mainFrame() == frame)
+    TryInitializeScale();
   // We don't always want to set up a timer, only if we've been put in that
   // mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
   // message.
   if (!send_preferred_size_changes_ || !webview())
     return;
 
   if (check_preferred_size_timer_.IsRunning())
     return;
   check_preferred_size_timer_.Start(TimeDelta::FromMilliseconds(0), this,
                                     &RenderView::CheckPreferredSize);
@@ skipping 16 matching lines @@
   size.set_height(static_cast<int>(size.height() * zoom_factor));
 
   if (size == preferred_size_)
     return;
 
   preferred_size_ = size;
   Send(new ViewHostMsg_DidContentsPreferredSizeChange(routing_id_,
                                                       preferred_size_));
 }
 
+gfx::Point RenderView::ClampOffsetAtScale(const gfx::Point& offset,
+                                          float scale) {
+  gfx::Point pt = offset;
+  float delta_scale = scale / GetPageScaleFactor();
+  int doc_width = GetContentSize().width() * delta_scale;
+  int doc_height = GetContentSize().height() * delta_scale;
+  pt.set_x(std::min(doc_width - size_.width(), pt.x()));
+  pt.set_y(std::min(doc_height - size_.height(), pt.y()));
+  pt.set_x(std::max(0, pt.x()));
+  pt.set_y(std::max(0, pt.y()));
+  return pt;
+}
+
+float RenderView::ComputeOverviewScale(gfx::Size content_size) {
+  if (content_size.IsEmpty() || size_.IsEmpty())
+    return 0.0f;
+  return ComputeScaleWithinLimits(0.0f);
+}
+
+float RenderView::ComputeScaleWithinLimits(float scale) {
+  // TODO(fsamuel): Need to take into account dpi scale.
+  float min_scale = minimum_scale_;
+  float max_scale = maximum_scale_;
+
+  gfx::Size content_size = GetContentSize();
+  if (!content_size.IsEmpty() && !size_.IsEmpty()) {
+    min_scale = std::max(min_scale, (float) size_.width() /
+                         (content_size.width() / GetPageScaleFactor()));
+  }
+  return std::min(std::max(scale, min_scale), max_scale);
+}
+
 void RenderView::didChangeContentsSize(WebFrame* frame, const WebSize& size) {
   if (webview()->mainFrame() != frame)
     return;
+
   WebView* frameView = frame->view();
   if (!frameView)
     return;
 
   bool has_horizontal_scrollbar = frame->hasHorizontalScrollbar();
   bool has_vertical_scrollbar = frame->hasVerticalScrollbar();
 
   if (has_horizontal_scrollbar != cached_has_main_frame_horizontal_scrollbar_ ||
       has_vertical_scrollbar != cached_has_main_frame_vertical_scrollbar_) {
     Send(new ViewHostMsg_DidChangeScrollbarsForMainFrame(
@@ skipping 225 matching lines @@
   // the selection hasn't actually changed. We don't want to report these
   // because it will cause us to continually claim the X clipboard.
   if (this_selection.Equals(last_selection_))
     return;
   last_selection_ = this_selection;
 
   Send(new ViewHostMsg_SelectionChanged(routing_id_, text, range,
                                         start, end));
 }
 
+bool RenderView::TryInitializeScale() {
+  // Make the page to fit the new size of the window if it wasn't set by
+  // the page or user yet.
+  if (page_scale_factor_set_)
+    return false;
+  float overview_scale = ComputeOverviewScale(GetContentSize());
+  if (overview_scale == 0.0f)
+    return false;
+  SetPageScaleFactor(overview_scale);
+  return true;
+}
+
+void RenderView::UpdatePageScale(gfx::Size new_content_size) {
+  float overview_scale = ComputeOverviewScale(new_content_size);
+  if (overview_scale == 0.0f)
+    return;
+  SetPageScaleFactor(overview_scale);
+}
+
 GURL RenderView::GetAlternateErrorPageURL(const GURL& failed_url,
                                           ErrorPageType error_type) {
 
   if (failed_url.SchemeIsSecure()) {
     // If the URL that failed was secure, then the embedding web page was not
     // expecting a network attacker to be able to manipulate its contents.  As
     // we fetch alternate error pages over HTTP, we would be allowing a network
     // attacker to manipulate the contents of the response if we tried to use
     // the link doctor here.
     return GURL();
@@ skipping 791 matching lines @@
   // navigation occurs, the fetcher will get destroyed.
   NavigationState* navigation_state =
       NavigationState::FromDataSource(frame->provisionalDataSource());
   navigation_state->set_alt_error_page_fetcher(
       new AltErrorPageResourceFetcher(
           error_page_url, frame, error,
           NewCallback(this, &RenderView::AltErrorPageFinished)));
   return true;
 }
 
+void RenderView::SetPageScaleFactor(float scale) {
+  scale = ComputeScaleWithinLimits(scale);
+  SetPageScaleFactorAndScroll(scale,
+      gfx::Point(GetScrollOffset().x() / GetPageScaleFactor() * scale,
+                 GetScrollOffset().y() / GetPageScaleFactor() * scale));
+}
+
+void RenderView::SetPageScaleFactorAndScroll(float scale,
+                                             const gfx::Point& offset) {
+  scale = ComputeScaleWithinLimits(scale);
+  gfx::Point pt = ClampOffsetAtScale(offset, scale);
+
+  if (scale != GetPageScaleFactor() || pt.x() != GetScrollOffset().x() ||
+      pt.y() != GetScrollOffset().y()) {
+    webview()->scalePage(scale, WebPoint(pt.x(), pt.y()));
+  }
+  page_scale_factor_set_ = true;
+}
+
+void RenderView::SetPageScaleFactorWithAnchor(float scale,
+                                              const gfx::Point& window_anchor) {
+  scale = ComputeScaleWithinLimits(scale);
+  gfx::Point old_offset = GetScrollOffset();
+  float old_scale = GetPageScaleFactor();
+  int anchor_x = window_anchor.x();
+  int anchor_y = window_anchor.y();
+  SetPageScaleFactorAndScroll(scale,
+      gfx::Point((anchor_x + old_offset.x()) * scale / old_scale - anchor_x,
+                 (anchor_y + old_offset.y()) * scale / old_scale - anchor_y));
+}
+
 void RenderView::AltErrorPageFinished(WebFrame* frame,
                                       const WebURLError& original_error,
                                       const std::string& html) {
   // Here, we replace the blank page we loaded previously.
   // If we failed to download the alternate error page, LoadNavigationErrorPage
   // will simply display a default error page.
   LoadNavigationErrorPage(frame, WebURLRequest(), original_error, html, true);
 }
 
 void RenderView::OnMoveOrResizeStarted() {
   if (webview())
     webview()->hidePopups();
 }
 
 void RenderView::OnResize(const gfx::Size& new_size,
                           const gfx::Rect& resizer_rect) {
   if (webview()) {
+

[jam, 2011/09/02 17:11:41]

?

     webview()->hidePopups();
     if (send_preferred_size_changes_) {
       webview()->mainFrame()->setCanHaveScrollbars(
           should_display_scrollbars(new_size.width(), new_size.height()));
     }
     UpdateScrollState(webview()->mainFrame());
   }
 
   RenderWidget::OnResize(new_size, resizer_rect);
+  if (webview()) {
+    // TODO(fsamuel): Need to detect case where the user set pageScaleFactor
+    // and adjust it appropriately on resize.
+    if (webview()->isFixedLayoutModeEnabled()) {
+      UpdatePageScale(new_size);
+    }
+  }
 }
 
 void RenderView::DidInitiatePaint() {
   // Notify the pepper plugins that we started painting.
   pepper_delegate_.ViewInitiatedPaint();
 }
 
 void RenderView::DidFlushPaint() {
   // Notify any pepper plugins that we painted. This will call into the plugin,
   // and we it may ask to close itself as a result. This will, in turn, modify
@@ skipping 41 matching lines @@
 
 webkit::ppapi::PluginInstance* RenderView::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip) {
   return pepper_delegate_.GetBitmapForOptimizedPluginPaint(
       paint_bounds, dib, location, clip);
 }
 
+gfx::Size RenderView::GetContentSize() {
+  WebKit::WebSize size = webview()->mainFrame()->contentsSize();
+  return gfx::Size(size.width, size.height);
+}
+
+float RenderView::GetPageScaleFactor() {
+  if (!webview())
+    return 1.0f;
+  return webview()->pageScaleFactor();
+}
+
 gfx::Point RenderView::GetScrollOffset() {
   WebSize scroll_offset = webview()->mainFrame()->scrollOffset();
   return gfx::Point(scroll_offset.width, scroll_offset.height);
 }
 
 void RenderView::OnClearFocusedNode() {
   if (webview())
     webview()->clearFocusedNode();
 }
 
@@ skipping 557 matching lines @@
 }
 
 void RenderView::OnEnableViewSourceMode() {
   if (!webview())
     return;
   WebFrame* main_frame = webview()->mainFrame();
   if (!main_frame)
     return;
   main_frame->enableViewSourceMode(true);
 }