Use bounds instead of size for prerender requests

chrome/browser/prerender/prerender_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <utility>
 
@@ skipping 16 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/prerender_types.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"

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

Need rect.h, too.

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

Done.

 #include "url/gurl.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 using content::Referrer;
 
 namespace prerender {
 
 class UnitTestPrerenderManager;
 
 namespace {
 
 class DummyPrerenderContents : public PrerenderContents {
  public:
   DummyPrerenderContents(UnitTestPrerenderManager* test_prerender_manager,
                          const GURL& url,
                          Origin origin,
                          FinalStatus expected_final_status);
 
   ~DummyPrerenderContents() override;
 
   void StartPrerendering(
-      const gfx::Size& size,
+      const gfx::Rect& bounds,
       content::SessionStorageNamespace* session_storage_namespace) override;
 
   bool GetChildId(int* child_id) const override {
     // Having a default child_id of -1 forces pending prerenders not to fail
     // on session storage and cross domain checking.
     *child_id = -1;
     return true;
   }
 
   bool GetRouteId(int* route_id) const override {
@@ skipping 211 matching lines @@
       route_id_(g_next_route_id_++),
       test_prerender_manager_(test_prerender_manager),
       expected_final_status_(expected_final_status) {}
 
 DummyPrerenderContents::~DummyPrerenderContents() {
   EXPECT_EQ(expected_final_status_, final_status());
   test_prerender_manager_->DummyPrerenderContentsDestroyed(-1, route_id_);
 }
 
 void DummyPrerenderContents::StartPrerendering(
-    const gfx::Size& size,
+    const gfx::Rect& bounds,
     content::SessionStorageNamespace* session_storage_namespace) {
   // In the base PrerenderContents implementation, StartPrerendering will
   // be called even when the PrerenderManager is part of the control group,
   // but it will early exit before actually creating a new RenderView if
   // |is_control_group| is true;
   load_start_time_ = test_prerender_manager_->GetCurrentTimeTicks();
   if (!test_prerender_manager_->IsControlGroup()) {
     prerendering_has_started_ = true;
     test_prerender_manager_->DummyPrerenderContentsStarted(-1, route_id_, this);
     NotifyPrerenderStart();
@@ skipping 786 matching lines @@
   EXPECT_TRUE(net::NetworkChangeNotifier::IsConnectionCellular(
       net::NetworkChangeNotifier::GetConnectionType()));
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           ORIGIN_EXTERNAL_REQUEST,
           FINAL_STATUS_MANAGER_SHUTDOWN);
   std::unique_ptr<PrerenderHandle> prerender_handle(
       prerender_manager()->AddPrerenderFromExternalRequest(
-          url, content::Referrer(), nullptr, kSize));
+          url, content::Referrer(), nullptr, gfx::Rect(kSize)));
   EXPECT_FALSE(prerender_handle);
   EXPECT_FALSE(prerender_contents->prerendering_has_started());
 }
 
 TEST_F(PrerenderTest, PrerenderAllowedForOfflineAndForcedCellular) {
   const Origin origins[] = {
     ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
     ORIGIN_OFFLINE,
   };
 
   EnablePrerender();
   std::unique_ptr<net::NetworkChangeNotifier> mock(
       new MockNetworkChangeNotifier4G);
   EXPECT_TRUE(net::NetworkChangeNotifier::IsConnectionCellular(
       net::NetworkChangeNotifier::GetConnectionType()));
   GURL url("http://www.google.com/");
   for (const Origin& origin : origins) {
     DummyPrerenderContents* prerender_contents = nullptr;
     std::unique_ptr<PrerenderHandle> prerender_handle;
     if (origin == ORIGIN_OFFLINE) {
       prerender_contents = prerender_manager()->CreateNextPrerenderContents(
           url, origin, FINAL_STATUS_MANAGER_SHUTDOWN);
       prerender_handle =
           prerender_manager()->AddPrerenderForOffline(url, nullptr, kSize);
     } else {
       prerender_contents = prerender_manager()->CreateNextPrerenderContents(
           url, origin, FINAL_STATUS_USED);
       prerender_handle =
           prerender_manager()->AddPrerenderOnCellularFromExternalRequest(
-              url, content::Referrer(), nullptr, kSize);
+              url, content::Referrer(), nullptr, gfx::Rect(kSize));
     }
     EXPECT_TRUE(prerender_handle);
     EXPECT_TRUE(prerender_handle->IsPrerendering());
     EXPECT_TRUE(prerender_contents->prerendering_has_started());
     EXPECT_EQ(prerender_contents, prerender_handle->contents());
     EXPECT_EQ(origin, prerender_handle->contents()->origin());
     if (origin != ORIGIN_OFFLINE) {
       std::unique_ptr<PrerenderContents> entry =
           prerender_manager()->FindAndUseEntry(url);
       ASSERT_EQ(prerender_contents, entry.get());
@@ skipping 518 matching lines @@
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_INSTANT, prerender_handle->contents()->origin());
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(url);
   ASSERT_EQ(prerender_contents, entry.get());
   EXPECT_FALSE(prerender_handle->IsPrerendering());
 }
 
 }  // namespace prerender