Use bounds instead of size for prerender requests

chrome/browser/prerender/prerender_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/prerender/prerender_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 217 matching lines @@
       return nullptr;
     if (origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN &&
         source_web_contents->GetURL().host_piece() == url.host_piece()) {
       origin = ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN;
     }
     // TODO(ajwong): This does not correctly handle storage for isolated apps.
     session_storage_namespace =
         source_web_contents->GetController()
             .GetDefaultSessionStorageNamespace();
   }
-
-  return AddPrerender(origin, url, referrer, size, session_storage_namespace);
+  return AddPrerender(
+      origin, url, referrer, gfx::Rect(size), session_storage_namespace);

[mmenke, 2016/08/19 15:22:29]

Need to include the header for gfx::Rect (Hrm...not sure we have the one for
gfx::size included, either)

[Yusuf, 2016/08/19 17:20:33]

Done.

 }
 
 std::unique_ptr<PrerenderHandle> PrerenderManager::AddPrerenderFromOmnibox(
     const GURL& url,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   if (!IsOmniboxEnabled(profile_))
     return nullptr;
-  return AddPrerender(ORIGIN_OMNIBOX, url, content::Referrer(), size,
+  return AddPrerender(ORIGIN_OMNIBOX, url, content::Referrer(), gfx::Rect(size),
                       session_storage_namespace);
 }
 
 std::unique_ptr<PrerenderHandle>
 PrerenderManager::AddPrerenderFromExternalRequest(
     const GURL& url,
     const content::Referrer& referrer,
     SessionStorageNamespace* session_storage_namespace,
-    const gfx::Size& size) {
-  return AddPrerender(
-      ORIGIN_EXTERNAL_REQUEST, url, referrer, size, session_storage_namespace);
+    const gfx::Rect& bounds) {
+  return AddPrerender(ORIGIN_EXTERNAL_REQUEST, url, referrer,
+                      bounds, session_storage_namespace);
 }
 
 std::unique_ptr<PrerenderHandle>
 PrerenderManager::AddPrerenderOnCellularFromExternalRequest(
     const GURL& url,
     const content::Referrer& referrer,
     SessionStorageNamespace* session_storage_namespace,
-    const gfx::Size& size) {
+    const gfx::Rect& bounds) {
   return AddPrerender(ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
                       url,
                       referrer,
-                      size,
+                      bounds,
                       session_storage_namespace);
 }
 
 std::unique_ptr<PrerenderHandle> PrerenderManager::AddPrerenderForInstant(
     const GURL& url,
     content::SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
-  return AddPrerender(ORIGIN_INSTANT, url, content::Referrer(), size,
+  return AddPrerender(ORIGIN_INSTANT, url, content::Referrer(), gfx::Rect(size),
                       session_storage_namespace);
 }
 
 std::unique_ptr<PrerenderHandle> PrerenderManager::AddPrerenderForOffline(
     const GURL& url,
     content::SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
-  return AddPrerender(ORIGIN_OFFLINE, url, content::Referrer(), size,
+  return AddPrerender(ORIGIN_OFFLINE, url, content::Referrer(), gfx::Rect(size),
                       session_storage_namespace);
 }
 
 void PrerenderManager::CancelAllPrerenders() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   while (!active_prerenders_.empty()) {
     PrerenderContents* prerender_contents =
         active_prerenders_.front()->contents();
     prerender_contents->Destroy(FINAL_STATUS_CANCELLED);
   }
@@ skipping 548 matching lines @@
 }
 
 bool PrerenderManager::IsLowEndDevice() const {
   return base::SysInfo::IsLowEndDevice();
 }
 
 std::unique_ptr<PrerenderHandle> PrerenderManager::AddPrerender(
     Origin origin,
     const GURL& url_arg,
     const content::Referrer& referrer,
-    const gfx::Size& size,
+    const gfx::Rect& bounds,
     SessionStorageNamespace* session_storage_namespace) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Allow only Requests for offlining on low end devices, the lifetime of
   // those prerenders is managed by the offliner.
   if (IsLowEndDevice() && origin != ORIGIN_OFFLINE)
     return nullptr;
 
   if ((origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN ||
        origin == ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN) &&
@@ skipping 80 matching lines @@
 
   histograms_->RecordPrerenderStarted(origin);
   DCHECK(!prerender_contents_ptr->prerendering_has_started());
 
   std::unique_ptr<PrerenderHandle> prerender_handle =
       base::WrapUnique(new PrerenderHandle(active_prerenders_.back().get()));
   SortActivePrerenders();
 
   last_prerender_start_time_ = GetCurrentTimeTicks();
 
-  gfx::Size contents_size =
-      size.IsEmpty() ? config_.default_tab_bounds.size() : size;
+  gfx::Rect contents_bounds =
+      bounds.IsEmpty() ? config_.default_tab_bounds : bounds;
 
-  prerender_contents_ptr->StartPrerendering(contents_size,
+  prerender_contents_ptr->StartPrerendering(contents_bounds,
                                             session_storage_namespace);
 
   DCHECK(IsControlGroup() ||
          prerender_contents_ptr->prerendering_has_started());
 
   if (GetMode() == PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP)
     histograms_->RecordConcurrency(active_prerenders_.size());
 
   StartSchedulingPeriodicCleanups();
   return prerender_handle;
@@ skipping 320 matching lines @@
   DCHECK_EQ(1u, erased);
 }
 
 void PrerenderManager::SetPrerenderContentsFactoryForTest(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 }  // namespace prerender