Migrating tests to use EmbeddedTestServer (misc)

chrome/renderer/safe_browsing/phishing_classifier_delegate_browsertest.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/renderer/safe_browsing/phishing_classifier_delegate.h"
 
 #include <stdint.h>
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 148 matching lines @@
     intercepting_filter_ = new InterceptingMessageFilter();
     render_view_routing_id_ =
         GetWebContents()->GetRenderViewHost()->GetRoutingID();
 
     GetWebContents()->GetRenderProcessHost()->AddFilter(
         intercepting_filter_.get());
     content::RenderFrame* render_frame = GetRenderView()->GetMainRenderFrame();
     classifier_ = new StrictMock<MockPhishingClassifier>(render_frame);
     delegate_ = PhishingClassifierDelegate::Create(render_frame, classifier_);
 
-    ASSERT_TRUE(StartTestServer());
+    embedded_test_server()->RegisterRequestHandler(
+        base::Bind(&PhishingClassifierDelegateTest::HandleRequest,
+                   base::Unretained(this)));
+    ASSERT_TRUE(embedded_test_server()->Start());
     host_resolver()->AddRule("*", "127.0.0.1");
   }
 
   // Runs the ClassificationDone callback, then waits for the
   // PhishingDetectionDone IPC to arrive.
   void RunClassificationDone(const ClientPhishingRequest& verdict) {
     // Clear out any previous state.
     intercepting_filter_->Reset();
     PostTaskToInProcessRendererAndWait(
         base::Bind(&PhishingClassifierDelegate::ClassificationDone,
         base::Unretained(delegate_),
         verdict));
     intercepting_filter_->RunUntilVerdictReceived();
   }
 
   void OnStartPhishingDetection(const GURL& url) {
     PostTaskToInProcessRendererAndWait(
         base::Bind(&PhishingClassifierDelegate::OnStartPhishingDetection,
                    base::Unretained(delegate_), url));
   }
 
   void PageCaptured(base::string16* page_text, bool preliminary_capture) {
     PostTaskToInProcessRendererAndWait(
         base::Bind(&PhishingClassifierDelegate::PageCaptured,
                    base::Unretained(delegate_), page_text,
                    preliminary_capture));
   }
 
-  bool StartTestServer() {
-    CHECK(!embedded_test_server_);
-    embedded_test_server_.reset(new net::test_server::EmbeddedTestServer());
-    embedded_test_server_->RegisterRequestHandler(
-        base::Bind(&PhishingClassifierDelegateTest::HandleRequest,
-                   base::Unretained(this)));
-    return embedded_test_server_->InitializeAndWaitUntilReady();
-  }
-
   scoped_ptr<net::test_server::HttpResponse> HandleRequest(
       const net::test_server::HttpRequest& request) {
     std::map<std::string, std::string>::const_iterator host_it =
         request.headers.find("Host");
     if (host_it == request.headers.end())
       return scoped_ptr<net::test_server::HttpResponse>();
 
     std::string url =
         std::string("http://") + host_it->second + request.relative_url;
     if (response_url_.spec() != url)
@@ skipping 14 matching lines @@
   content::RenderView* GetRenderView() {
     return content::RenderView::FromRoutingID(render_view_routing_id_);
   }
 
   // Returns the URL that was loaded.
   GURL LoadHtml(const std::string& host, const std::string& content) {
     GURL::Replacements replace_host;
     replace_host.SetHostStr(host);
     response_content_ = content;
     response_url_ =
-        embedded_test_server_->base_url().ReplaceComponents(replace_host);
+        embedded_test_server()->base_url().ReplaceComponents(replace_host);
     ui_test_utils::NavigateToURL(browser(), response_url_);
     return response_url_;
   }
 
   void GoBack() {
     GetWebContents()->GetController().GoBack();
     content::WaitForLoadStop(GetWebContents());
   }
 
   void GoForward() {
     GetWebContents()->GetController().GoForward();
     content::WaitForLoadStop(GetWebContents());
   }
 
   scoped_refptr<InterceptingMessageFilter> intercepting_filter_;
   GURL response_url_;
   std::string response_content_;
-  scoped_ptr<net::test_server::EmbeddedTestServer> embedded_test_server_;
   scoped_ptr<ClientPhishingRequest> verdict_;
   StrictMock<MockPhishingClassifier>* classifier_;  // Owned by |delegate_|.
   int32_t render_view_routing_id_;
   PhishingClassifierDelegate* delegate_;  // Owned by the RenderView.
   scoped_refptr<content::MessageLoopRunner> runner_;
 };
 
 IN_PROC_BROWSER_TEST_F(PhishingClassifierDelegateTest, Navigation) {
   MockScorer scorer;
   delegate_->SetPhishingScorer(&scorer);
   ASSERT_TRUE(classifier_->is_ready());
 
   // Test an initial load.  We expect classification to happen normally.
   EXPECT_CALL(*classifier_, CancelPendingClassification());
-  std::string port = base::UintToString(embedded_test_server_->port());
-  std::string html = "<html><body><iframe src=\"http://sub1.com:";
-  html += port;
-  html += "/\"></iframe></body></html>";
+  GURL iframe_url = embedded_test_server()->GetURL("/");
+  GURL::Replacements replace_host;
+  replace_host.SetHostStr("sub1.com");
+  std::string html = "<html><body><iframe src=\"";
+  html += iframe_url.ReplaceComponents(replace_host).spec();
+  html += "\"></iframe></body></html>";
   GURL url = LoadHtml("host.com", html);
   Mock::VerifyAndClearExpectations(classifier_);
   OnStartPhishingDetection(url);
   base::string16 page_text = ASCIIToUTF16("dummy");
   {
     InSequence s;
     EXPECT_CALL(*classifier_, CancelPendingClassification());
     EXPECT_CALL(*classifier_, BeginClassification(Pointee(page_text), _));
     PageCaptured(&page_text, false);
     Mock::VerifyAndClearExpectations(classifier_);
@@ skipping 226 matching lines @@
   EXPECT_CALL(*classifier_, CancelPendingClassification());
   PageCaptured(&page_text, false);
   Mock::VerifyAndClearExpectations(classifier_);
   EXPECT_CALL(*classifier_, CancelPendingClassification());
 
   ui_test_utils::NavigateToURL(
       browser(), GURL("javascript:location.replace(\'redir\');"));
 
   Mock::VerifyAndClearExpectations(classifier_);
 
-  std::string url_str = "http://host4.com:";
-  url_str += base::UintToString(embedded_test_server_->port());
-  url_str += "/redir";
-  OnStartPhishingDetection(GURL(url_str));
+  GURL redir_url = embedded_test_server()->GetURL("/redir");
+  GURL::Replacements replace_host;
+  replace_host.SetHostStr("host4.com");
+  OnStartPhishingDetection(redir_url.ReplaceComponents(replace_host));
   page_text = ASCIIToUTF16("123");
   {
     InSequence s;
     EXPECT_CALL(*classifier_, CancelPendingClassification());
     EXPECT_CALL(*classifier_, BeginClassification(Pointee(page_text), _));
     PageCaptured(&page_text, false);
     Mock::VerifyAndClearExpectations(classifier_);
   }
 
   // The delegate will cancel pending classification on destruction.
@@ skipping 105 matching lines @@
   RunClassificationDone(verdict);
   ASSERT_TRUE(intercepting_filter_->verdict());
   EXPECT_EQ(verdict.SerializeAsString(),
             intercepting_filter_->verdict()->SerializeAsString());
 
   // The delegate will cancel pending classification on destruction.
   EXPECT_CALL(*classifier_, CancelPendingClassification());
 }
 
 }  // namespace safe_browsing