Use bounds instead of size for prerender requests

chrome/browser/prerender/prerender_contents.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_contents.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 151 matching lines @@
                                const GURL& url,
                                bool user_gesture) override {
     // TODO(mmenke): Consider supporting this if it is a common case during
     // prerenders.
     prerender_contents_->Destroy(FINAL_STATUS_REGISTER_PROTOCOL_HANDLER);
   }
 
   gfx::Size GetSizeForNewRenderView(WebContents* web_contents) const override {
     // Have to set the size of the RenderView on initialization to be sure it is
     // set before the RenderView is hidden on all platforms (esp. Android).
-    return prerender_contents_->size_;
+    return prerender_contents_->bounds_.size();
   }
 
  private:
   PrerenderContents* prerender_contents_;
 };
 
 void PrerenderContents::Observer::OnPrerenderStopLoading(
     PrerenderContents* contents) {
 }
 
@@ skipping 45 matching lines @@
   if (!web_contents)
     return NULL;
   PrerenderManager* prerender_manager = PrerenderManagerFactory::GetForProfile(
       Profile::FromBrowserContext(web_contents->GetBrowserContext()));
   if (!prerender_manager)
     return NULL;
   return prerender_manager->GetPrerenderContents(web_contents);
 }
 
 void PrerenderContents::StartPrerendering(
-    const gfx::Size& size,
+    const gfx::Rect& bounds,
     SessionStorageNamespace* session_storage_namespace) {
   DCHECK(profile_);
-  DCHECK(!size.IsEmpty());
+  DCHECK(!bounds.IsEmpty());

[Benoit L, 2016/08/19 12:49:49]

Isn't this going to be hit by the test in ExternalPrerenderHandlerTest.java:118?

(or at least create some flakiness if there is a race).

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

Actually, before prerender_manager calls this, we always check whether the one
sent to addPrerender is empty and set to default_bounds_ if it is. So by the
time we are here, it is always non-empty.

   DCHECK(!prerendering_has_started_);
   DCHECK(!prerender_contents_);
-  DCHECK(size_.IsEmpty());
   DCHECK_EQ(1U, alias_urls_.size());
 
   session_storage_namespace_id_ = session_storage_namespace->id();
-  size_ = size;
+  bounds_ = bounds;
 
   DCHECK(load_start_time_.is_null());
   load_start_time_ = base::TimeTicks::Now();
 
   // Everything after this point sets up the WebContents object and associated
   // RenderView for the prerender page. Don't do this for members of the
   // control group.
   if (prerender_manager_->IsControlGroup())
     return;
 
   prerendering_has_started_ = true;
 
   prerender_contents_.reset(CreateWebContents(session_storage_namespace));
   TabHelpers::AttachTabHelpers(prerender_contents_.get());
   content::WebContentsObserver::Observe(prerender_contents_.get());
 
   // Tag the prerender contents with the task manager specific prerender tag, so
   // that it shows up in the task manager.
   task_manager::WebContentsTags::CreateForPrerenderContents(
       prerender_contents_.get());
 
   web_contents_delegate_.reset(new WebContentsDelegateImpl(this));
   prerender_contents_.get()->SetDelegate(web_contents_delegate_.get());
   // Set the size of the prerender WebContents.
-  ResizeWebContents(prerender_contents_.get(), size_);
+  ResizeWebContents(prerender_contents_.get(), bounds_);
 
   // TODO(davidben): This logic assumes each prerender has at most one
   // route. https://crbug.com/440544
   child_id_ = GetRenderViewHost()->GetProcess()->GetID();
   route_id_ = GetRenderViewHost()->GetRoutingID();
 
   // TODO(davidben): This logic assumes each prerender has at most one
   // process. https://crbug.com/440544
   prerender_manager()->AddPrerenderProcessHost(
       GetRenderViewHost()->GetProcess());
@@ skipping 436 matching lines @@
 void PrerenderContents::AddResourceThrottle(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle) {
   resource_throttles_.push_back(throttle);
 }
 
 void PrerenderContents::AddNetworkBytes(int64_t bytes) {
   network_bytes_ += bytes;
 }
 
 }  // namespace prerender