Move navigations with POST or referrer to the shell.

mojo/shell/application_manager_unittest.cc

 // Copyright 2014 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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/application/public/cpp/application_connection.h"
@@ skipping 22 matching lines @@
  public:
   explicit TestMimeTypeFetcher(const FetchCallback& fetch_callback)
       : Fetcher(fetch_callback), url_("xxx") {
     loader_callback_.Run(make_scoped_ptr(this));
   }
   ~TestMimeTypeFetcher() override {}
 
   // Fetcher:
   const GURL& GetURL() const override { return url_; }
   GURL GetRedirectURL() const override { return GURL("yyy"); }
+  GURL GetRedirectReferer() const override { return GURL(); }
   URLResponsePtr AsURLResponse(base::TaskRunner* task_runner,
                                uint32_t skip) override {
     return URLResponse::New().Pass();
   }
   void AsPath(
       base::TaskRunner* task_runner,
       base::Callback<void(const base::FilePath&, bool)> callback) override {}
   std::string MimeType() override { return kTestMimeType; }
   bool HasMojoMagic() override { return false; }
   bool PeekFirstLine(std::string* line) override { return false; }
@@ skipping 225 matching lines @@
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public TestA {
  public:
   TestAImpl(ApplicationImpl* app_impl,
             TesterContext* test_context,
             InterfaceRequest<TestA> request)
       : test_context_(test_context), binding_(this, request.Pass()) {
-    app_impl->ConnectToApplication(kTestBURLString)->ConnectToService(&b_);
+    mojo::URLRequestPtr request2(mojo::URLRequest::New());
+    request2->url = mojo::String::From(kTestBURLString);
+    app_impl->ConnectToApplication(request2.Pass())->ConnectToService(&b_);
   }
 
   ~TestAImpl() override {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
  private:
   void CallB() override {
@@ skipping 461 matching lines @@
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(1, scheme_loader->num_loads());
 }
 
 TEST_F(ApplicationManagerTest, TestEndApplicationClosure) {
   ClosingApplicationLoader* loader = new ClosingApplicationLoader();
   application_manager_->SetLoaderForScheme(
       scoped_ptr<ApplicationLoader>(loader), "test");
 
   bool called = false;
+  mojo::URLRequestPtr request(mojo::URLRequest::New());
+  request->url = mojo::String::From("test:test");
   application_manager_->ConnectToApplication(
-      GURL("test:test"), GURL(), nullptr, nullptr,
+      request.Pass(), GURL(), nullptr, nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 TEST(ApplicationManagerTest2, ContentHandlerConnectionGetsRequestorURL) {
   const GURL content_handler_url("http://test.content.handler");
   const GURL requestor_url("http://requestor.url");
   TestContext test_context;
   base::MessageLoop loop;
   TestDelegate test_delegate;
   test_delegate.set_create_test_fetcher(true);
   ApplicationManager application_manager(&test_delegate);
   application_manager.set_default_loader(nullptr);
   application_manager.RegisterContentHandler(kTestMimeType,
                                              content_handler_url);
 
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&test_context);
   application_manager.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader),
                                       content_handler_url);
 
   bool called = false;
+  mojo::URLRequestPtr request(mojo::URLRequest::New());
+  request->url = mojo::String::From("test:test");
   application_manager.ConnectToApplication(
-      GURL("test:test"), requestor_url, nullptr, nullptr,
+      request.Pass(), requestor_url, nullptr, nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop.Run();
   EXPECT_TRUE(called);
 
   ASSERT_EQ(1, loader->num_loads());
   EXPECT_EQ(requestor_url, loader->last_requestor_url());
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo