Issue 5180 - stop using of WebRequestPtr in tests

test/FilterEngine.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 35 matching lines @@
   template<class FileSystem, class LogSystem>
   class FilterEngineTestGeneric : public BaseJsTest
   {
   protected:
     FilterEnginePtr filterEngine;
 
     void SetUp() override
     {
       BaseJsTest::SetUp();
       jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(new FileSystem));
-      jsEngine->SetWebRequest(AdblockPlus::WebRequestPtr(new LazyWebRequest));
+      jsEngine->SetWebRequest(std::make_shared<LazyWebRequest>());
       jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(new LogSystem));
       filterEngine = AdblockPlus::FilterEngine::Create(jsEngine);
     }
     void TearDown() override
     {
       // Workaround for issue 5198
       std::this_thread::sleep_for(std::chrono::milliseconds(100));
     }
   };
 
   typedef FilterEngineTestGeneric<LazyFileSystem, AdblockPlus::DefaultLogSystem> FilterEngineTest;
   typedef FilterEngineTestGeneric<VeryLazyFileSystem, LazyLogSystem> FilterEngineTestNoData;
 
   class UpdaterTest : public ::testing::Test
   {
   protected:
     class MockWebRequest : public AdblockPlus::WebRequest
     {
     public:
       AdblockPlus::ServerResponse response;
 
       AdblockPlus::ServerResponse GET(const std::string& url,
           const AdblockPlus::HeaderList& requestHeaders) const
       {
         return response;
       }
     };
 
-    MockWebRequest* mockWebRequest;
+    std::shared_ptr<MockWebRequest> mockWebRequest;
     FilterEnginePtr filterEngine;
 
     void SetUp()
     {
       AdblockPlus::AppInfo appInfo;
       appInfo.name = "test";
       appInfo.version = "1.0.1";
       AdblockPlus::JsEnginePtr jsEngine = CreateJsEngine(appInfo);
       jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(new LazyFileSystem));
-      mockWebRequest = new MockWebRequest;
-      jsEngine->SetWebRequest(AdblockPlus::WebRequestPtr(mockWebRequest));
+      jsEngine->SetWebRequest(mockWebRequest = std::make_shared<MockWebRequest>());
       filterEngine = AdblockPlus::FilterEngine::Create(jsEngine);
     }
   };
 
   class FilterEngineWithFreshFolder : public ::testing::Test
   {
   protected:
     FileSystemPtr fileSystem;
     std::weak_ptr<JsEngine> weakJsEngine;
 
     void SetUp() override
     {
       fileSystem.reset(new DefaultFileSystem());
       // Since there is neither in memory FS nor functionality to work with
       // directories use the hack: manually clean the directory.
       removeFileIfExists("patterns.ini");
       removeFileIfExists("prefs.json");
     }
     JsEnginePtr createJsEngine(const AppInfo& appInfo = AppInfo())
     {
       auto jsEngine = JsEngine::New(appInfo);
       weakJsEngine = jsEngine;
       jsEngine->SetFileSystem(fileSystem);
-      jsEngine->SetWebRequest(AdblockPlus::WebRequestPtr(new LazyWebRequest()));
+      jsEngine->SetWebRequest(std::make_shared<LazyWebRequest>());
       jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(new LazyLogSystem()));
       return jsEngine;
     }
     void TearDown() override
     {
       removeFileIfExists("patterns.ini");
       removeFileIfExists("prefs.json");
       fileSystem.reset();
     }
     void removeFileIfExists(const std::string& path)
@@ skipping 55 matching lines @@
       void Clear()
       {
         std::lock_guard<std::mutex> lock(mutex);
         strings.clear();
       }
     private:
       mutable std::mutex mutex;
       std::vector<std::pair<bool, std::string>> strings;
     };
   protected:
-    MockWebRequest* webRequest;
+    std::shared_ptr<MockWebRequest> webRequest;
     std::string subscriptionUrlPrefix;
     FilterEngine::CreationParameters createParams;
     // HACK: it's a shared pointer to keep it available in
     // isConnectionAllowedCallback after destroying of the test.
     struct SharedData
     {
       SyncStrings capturedConnectionTypes;
       bool isConnectionAllowed;
       struct
       {
         std::string url;
         std::mutex mutex;
         std::condition_variable cv;
       } downloadStatusChanged;
     };
     std::shared_ptr<SharedData> data;
     FilterEnginePtr filterEngine;
 
     void SetUp()
     {
       data = std::make_shared<SharedData>();
       BaseJsTest::SetUp();
       jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(new LazyFileSystem()));
-      jsEngine->SetWebRequest(AdblockPlus::WebRequestPtr(webRequest = new MockWebRequest()));
+      jsEngine->SetWebRequest(webRequest = std::make_shared<MockWebRequest>());
       jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(new LazyLogSystem()));
 
       subscriptionUrlPrefix = "http://example";
       ServerResponse exampleSubscriptionResponse;
       exampleSubscriptionResponse.responseStatus = 200;
       exampleSubscriptionResponse.status = WebRequest::NS_OK;
       exampleSubscriptionResponse.responseText = "[Adblock Plus 2.0]\n||example.com";
       webRequest->responses.emplace(subscriptionUrlPrefix, exampleSubscriptionResponse);
       createParams.preconfiguredPrefs.emplace("first_run_subscription_auto_select", jsEngine->NewValue(false));
       data->isConnectionAllowed = true;
@@ skipping 901 matching lines @@
     filterEngine->SetAllowedConnectionType(&testConnection);
     auto subscription = EnsureExampleSubscriptionAndForceUpdate("subB");
     EXPECT_EQ("synchronize_ok", subscription.GetProperty("downloadStatus").AsString());
     EXPECT_EQ(1u, subscription.GetProperty("filters").AsList().size());
     auto capturedConnectionTypes = data->capturedConnectionTypes.GetStrings();
     ASSERT_EQ(1u, capturedConnectionTypes.size());
     EXPECT_TRUE(capturedConnectionTypes[0].first);
     EXPECT_EQ(testConnection, capturedConnectionTypes[0].second);
   }
 }