Refactor PostOnSamePage test to ensure the form is posted.

ios/chrome/browser/web/browsing_egtest.mm

 // 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.
 
 #import <XCTest/XCTest.h>
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/ios/ios_util.h"
@@ skipping 27 matching lines @@
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 using chrome_test_util::OmniboxText;
 
 namespace {
 
 // URL used for the reload test.
 const char kReloadTestUrl[] = "http://mock/reloadTest";
+const char kFormPageUrl[] = "http://form/";
+const char kFirstPageUrl[] = "http://first/";
 
 // Returns the number of serviced requests in HTTP body.
 class ReloadResponseProvider : public web::DataResponseProvider {
  public:
   ReloadResponseProvider() : request_number_(0) {}
 
   // URL used for the reload test.
   static GURL GetReloadTestUrl() {
     return web::test::HttpServer::MakeUrl(kReloadTestUrl);
   }
@@ skipping 13 matching lines @@
 
   // static
   static std::string GetResponseBody(int request_number) {
     return base::StringPrintf("Load request %d", request_number);
   }
 
  private:
   int request_number_;  // Count of requests received by the response provider.
 };
 
+// A ResponseProvider that provides post form on the same page.
+class TestPostFormResponseProvider : public web::DataResponseProvider {

[Eugene But (OOO till 7-30), 2017/06/24 00:26:09]

Looks like forms_egtest has a response provider that prints HPPT method. Can we
reuse that existing code? Moving |testBrowsingPostToSamePage| to forms_egtest
sounds like a reasonable direction.

+ public:
+  // URLs used for the post form test.
+  static GURL GetFirstPageUrl() {
+    return web::test::HttpServer::MakeUrl(kFirstPageUrl);
+  }
+  static GURL GetFormPageUrl() {
+    return web::test::HttpServer::MakeUrl(kFormPageUrl);
+  }
+
+  bool CanHandleRequest(const Request& request) override {
+    return request.url == GetFormPageUrl() || request.url == GetFirstPageUrl();
+  }
+  void GetResponseHeadersAndBody(
+      const Request& request,
+      scoped_refptr<net::HttpResponseHeaders>* headers,
+      std::string* response_body) override {
+    const GURL& url = request.url;
+    *headers = web::ResponseProvider::GetDefaultResponseHeaders();
+    if (url == GetFirstPageUrl()) {
+      *response_body = "foo";
+      return;
+    } else if (url == GetFormPageUrl()) {
+      if (request.method == "POST") {
+        *response_body = request.method + std::string(" ") + request.body;
+      } else {
+        *response_body =
+            "<form method='post'>"
+            "<input value='button' type='submit' id='button'></form>";
+      }
+      return;
+    }
+    NOTREACHED();
+  }
+};
+
 // ScopedBlockPopupsPref modifies the block popups preference and resets the
 // preference to its original value when this object goes out of scope.
 // TODO(crbug.com/638674): Evaluate if this can move to shared code
 class ScopedBlockPopupsPref {
  public:
   ScopedBlockPopupsPref(ContentSetting setting) {
     original_setting_ = GetPrefValue();
     SetPrefValue(setting);
   }
   ~ScopedBlockPopupsPref() { SetPrefValue(original_setting_); }
@@ skipping 338 matching lines @@
   // onclick event.
   [[EarlGrey selectElementWithMatcher:OmniboxText("chrome://version")]
       assertWithMatcher:grey_nil()];
   [ChromeEarlGrey waitForWebViewContainingText:"Hello world!"];
 
   // Verify that no new tabs were open which could load chrome://version.
   chrome_test_util::AssertMainTabCount(1U);
 }
 
 // Tests that pressing the button on a POST-based form with same-page action
-// does not change the page and that the back button works as expected
+// does not change the page URL and that the back button works as expected
 // afterwards.
 - (void)testBrowsingPostToSamePage {
 // TODO(crbug.com/714303): Re-enable this test on devices.
 #if !TARGET_IPHONE_SIMULATOR
   EARL_GREY_TEST_DISABLED(@"Test disabled on device.");
 #endif
 
-  // Create map of canned responses and set up the test HTML server.
-  std::map<GURL, std::string> responses;
-  const GURL firstURL = web::test::HttpServer::MakeUrl("http://first");
-  const GURL formURL = web::test::HttpServer::MakeUrl("http://form");
-  // This is just a page with some text.
-  responses[firstURL] = "foo";
-  // This is a page with at button that posts to the current URL.
-  responses[formURL] =
-      "<form method='post'>"
-      "<input value='button' type='submit' id='button'></form>";
-  web::test::SetUpSimpleHttpServer(responses);
+  // Set up test HTTP server responses.
+  std::unique_ptr<web::DataResponseProvider> provider(
+      new TestPostFormResponseProvider());
+  web::test::SetUpHttpServer(std::move(provider));
+  const GURL firstURL = TestPostFormResponseProvider::GetFirstPageUrl();
+  const GURL formURL = TestPostFormResponseProvider::GetFormPageUrl();
 
   // Open the first URL so it's in history.
   [ChromeEarlGrey loadURL:firstURL];
 
   // Open the second URL, tap the button, and verify the browser navigates to
   // the expected URL.
   [ChromeEarlGrey loadURL:formURL];
   chrome_test_util::TapWebViewElementWithId("button");
+  [ChromeEarlGrey waitForWebViewContainingText:"POST"];
   [[EarlGrey selectElementWithMatcher:OmniboxText(formURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Go back once and verify the browser navigates to the form URL.
   [self goBack];
   [[EarlGrey selectElementWithMatcher:OmniboxText(formURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Go back a second time and verify the browser navigates to the first URL.
   [self goBack];
@@ skipping 166 matching lines @@
       assertWithMatcher:grey_notNil()];
 
   // Go back and verify that the browser navigates to the original URL.
   [self goBack];
   [ChromeEarlGrey waitForWebViewContainingText:"hello!"];
   [[EarlGrey selectElementWithMatcher:OmniboxText(URL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 @end