Fix some WebContents leaks in prerendering tests

chrome/browser/android/offline_pages/prerendering_loader_unittest.cc

 // Copyright 2016 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/android/offline_pages/prerendering_loader.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 
 // Adapter that intercepts prerender stack calls for testing.
 class TestAdapter : public PrerenderAdapter {
  public:
   explicit TestAdapter(PrerenderAdapter::Observer* observer)
       : PrerenderAdapter(observer),
         active_(false),
         disabled_(false),
         fail_start_(false),
         observer_(observer),
-        web_contents_(nullptr),
         final_status_(prerender::FINAL_STATUS_MAX) {}
   ~TestAdapter() override {}
 
   // PrerenderAdapter implementation.
   bool CanPrerender() const override;
   bool StartPrerender(
       content::BrowserContext* browser_context,
       const GURL& url,
       content::SessionStorageNamespace* session_storage_namespace,
       const gfx::Size& size) override;
@@ skipping 14 matching lines @@
                  prerender::FinalStatus final_status);
 
   // Returns the observer for test access.
   PrerenderAdapter::Observer* GetObserver() const { return observer_; }
 
  private:
   bool active_;
   bool disabled_;
   bool fail_start_;
   PrerenderAdapter::Observer* observer_;
-  content::WebContents* web_contents_;
+  std::unique_ptr<content::WebContents> web_contents_;
   prerender::FinalStatus final_status_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAdapter);
 };
 
 void TestAdapter::Disable() {
   disabled_ = true;
 }
 
 void TestAdapter::FailStart() {
   fail_start_ = true;
 }
 
 void TestAdapter::Configure(content::WebContents* web_contents,
                             prerender::FinalStatus final_status) {
-  web_contents_ = web_contents;
+  web_contents_ = base::WrapUnique(web_contents);
   final_status_ = final_status;
 }
 
 bool TestAdapter::CanPrerender() const {
   return !disabled_;
 }
 
 bool TestAdapter::StartPrerender(
     content::BrowserContext* browser_context,
     const GURL& url,
     content::SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   if (fail_start_)
     return false;
   active_ = true;
   return true;
 }
 
 content::WebContents* TestAdapter::GetWebContents() const {
-  return web_contents_;
+  return web_contents_.get();
 }
 
 prerender::FinalStatus TestAdapter::GetFinalStatus() const {
   return final_status_;
 }
 
 bool TestAdapter::IsActive() const {
   return active_;
 }
 
@@ skipping 269 matching lines @@
   test_adapter()->FailStart();
   GURL gurl("http://testit.sea");
   EXPECT_TRUE(loader()->IsIdle());
   EXPECT_FALSE(loader()->LoadPage(
       gurl,
       base::Bind(&PrerenderingLoaderTest::OnLoadDone, base::Unretained(this))));
   EXPECT_TRUE(loader()->IsIdle());
 }
 
 }  // namespace offline_pages