Move clear cache code from chrome/ (ChromeWVGDelegate) to extensions/ (WVGuest)

chrome/browser/apps/guest_view/web_view_browsertest.cc

 // Copyright 2013 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/path_service.h"
 #include "base/process/process.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
@@ skipping 71 matching lines @@
 using task_manager::browsertest_util::MatchApp;
 using task_manager::browsertest_util::MatchBackground;
 using task_manager::browsertest_util::MatchWebView;
 using task_manager::browsertest_util::WaitForTaskManagerRows;
 using ui::MenuModel;
 
 namespace {
 const char kEmptyResponsePath[] = "/close-socket";
 const char kRedirectResponsePath[] = "/server-redirect";
 const char kUserAgentRedirectResponsePath[] = "/detect-user-agent";
+const char kCacheResponsePath[] = "/cache-control-response";
 const char kRedirectResponseFullPath[] =
     "/extensions/platform_apps/web_view/shim/guest_redirect.html";
 
 class EmptyHttpResponse : public net::test_server::HttpResponse {
  public:
   std::string ToResponseString() const override { return std::string(); }
 };
 
 class TestInterstitialPageDelegate : public content::InterstitialPageDelegate {
  public:
@@ skipping 147 matching lines @@
 
  private:
   bool requested_;
   bool checked_;
   scoped_refptr<content::MessageLoopRunner> request_message_loop_runner_;
   scoped_refptr<content::MessageLoopRunner> check_message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate);
 };
 
-class MockWebViewGuestDelegate : public extensions::WebViewGuestDelegate {
- public:
-  explicit MockWebViewGuestDelegate(extensions::WebViewGuest* web_view_guest)
-      : web_view_guest_(web_view_guest), clear_cache_called_(false) {}
-  ~MockWebViewGuestDelegate() override {}
-
-  // WebViewGuestDelegate implementation.
-  void ClearCache(base::Time remove_since,
-                  const base::Closure& callback) override {
-    clear_cache_called_ = true;
-    base::MessageLoop::current()->PostTask(FROM_HERE, callback);
-  }
-  bool HandleContextMenu(const content::ContextMenuParams& params) override {
-    return false;
-  }
-  void OnAttachWebViewHelpers(content::WebContents* contents) override {}
-  void OnDidCommitProvisionalLoadForFrame(bool is_main_frame) override {}
-  void OnDidInitialize() override {}
-  void OnDocumentLoadedInFrame(
-      content::RenderFrameHost* render_frame_host) override {}
-  void OnGuestDestroyed() override {}
-  void OnShowContextMenu(
-      int request_id,
-      const WebViewGuestDelegate::MenuItemVector* items) override {}
-
-  bool clear_cache_called() { return clear_cache_called_; }
-
- private:
-  extensions::WebViewGuest* web_view_guest_;
-  bool clear_cache_called_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockWebViewGuestDelegate);
-};
-
 // This class intercepts download request from the guest.
 class MockDownloadWebContentsDelegate : public content::WebContentsDelegate {
  public:
   explicit MockDownloadWebContentsDelegate(
       content::WebContentsDelegate* orig_delegate)
       : orig_delegate_(orig_delegate),
         waiting_for_decision_(false),
         expect_allow_(false),
         decision_made_(false),
         last_download_allowed_(false) {}
@@ skipping 298 matching lines @@
         new net::test_server::BasicHttpResponse);
     http_response->set_code(net::HTTP_MOVED_PERMANENTLY);
     http_response->AddCustomHeader("Location", redirect_target.spec());
     return http_response.Pass();
   }
 
   // Handles |request| by serving an empty response.
   static scoped_ptr<net::test_server::HttpResponse> EmptyResponseHandler(
       const std::string& path,
       const net::test_server::HttpRequest& request) {
-    if (StartsWithASCII(path, request.relative_url, true)) {
-      return scoped_ptr<net::test_server::HttpResponse>(
-          new EmptyHttpResponse);
-    }
+    if (StartsWithASCII(path, request.relative_url, true))
+      return scoped_ptr<net::test_server::HttpResponse>(new EmptyHttpResponse);
 
     return scoped_ptr<net::test_server::HttpResponse>();
   }
 
+  // Handles |request| by serving cache-able response.
+  static scoped_ptr<net::test_server::HttpResponse> CacheControlResponseHandler(
+      const std::string& path,
+      const net::test_server::HttpRequest& request) {
+    if (!StartsWithASCII(path, request.relative_url, true))
+      return scoped_ptr<net::test_server::HttpResponse>();
+
+    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+        new net::test_server::BasicHttpResponse);
+    http_response->AddCustomHeader("Cache-control", "max-age=3600");
+    http_response->set_content_type("text/plain");
+    http_response->set_content("dummy text");
+    return http_response.Pass();
+  }
+
   // Shortcut to return the current MenuManager.
   extensions::MenuManager* menu_manager() {
     return extensions::MenuManager::Get(browser()->profile());
   }
 
   // This gets all the items that any extension has registered for possible
   // inclusion in context menus.
   MenuItem::List GetItems() {
     MenuItem::List result;
     std::set<MenuItem::ExtensionKey> extension_ids =
@@ skipping 26 matching lines @@
                     embedded_test_server()->GetURL(kRedirectResponseFullPath)));
 
       embedded_test_server()->RegisterRequestHandler(
           base::Bind(&WebViewTest::EmptyResponseHandler, kEmptyResponsePath));
 
       embedded_test_server()->RegisterRequestHandler(
           base::Bind(
               &WebViewTest::UserAgentResponseHandler,
               kUserAgentRedirectResponsePath,
               embedded_test_server()->GetURL(kRedirectResponseFullPath)));
+
+      embedded_test_server()->RegisterRequestHandler(base::Bind(
+          &WebViewTest::CacheControlResponseHandler, kCacheResponsePath));
     }
 
     LoadAndLaunchPlatformApp(app_location.c_str(), "Launched");
 
     // Flush any pending events to make sure we start with a clean slate.
     content::RunAllPendingInMessageLoop();
 
     content::WebContents* embedder_web_contents =
         GetFirstAppWindowWebContents();
     if (!embedder_web_contents) {
@@ skipping 1752 matching lines @@
     return;
 #endif
 
   ASSERT_TRUE(StartEmbeddedTestServer());  // For serving guest pages.
   ASSERT_TRUE(RunPlatformAppTestWithArg(
       "platform_apps/web_view/common", "cleardata"))
           << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewTest, ClearDataCache) {
-  LoadAppWithGuest("web_view/clear_data_cache");
-  content::WebContents* guest_web_contents = GetGuestWebContents();
-  auto guest = extensions::WebViewGuest::FromWebContents(guest_web_contents);
-  ASSERT_TRUE(guest);
-  scoped_ptr<extensions::WebViewGuestDelegate> mock_web_view_guest_delegate(
-      new MockWebViewGuestDelegate(guest));
-  scoped_ptr<extensions::WebViewGuestDelegate> orig_web_view_guest_delegate =
-      guest->SetDelegateForTesting(mock_web_view_guest_delegate.Pass());
-
-  ASSERT_TRUE(GetEmbedderWebContents());
-  ExtensionTestMessageListener clear_data_done_listener(
-      "WebViewTest.CLEAR_DATA_DONE", false);
-  EXPECT_TRUE(content::ExecuteScript(
-      GetEmbedderWebContents(), base::StringPrintf("testClearDataCache()")));
-  EXPECT_TRUE(clear_data_done_listener.WaitUntilSatisfied());
-
-  // Reset delegate back to original once we're done mocking.
-  mock_web_view_guest_delegate =
-      guest->SetDelegateForTesting(orig_web_view_guest_delegate.Pass());
+  TestHelper("testClearCache", "web_view/clear_data_cache", NEEDS_TEST_SERVER);
 }
 
 // This test is disabled on Win due to being flaky. http://crbug.com/294592
 #if defined(OS_WIN)
 #define MAYBE_ConsoleMessage DISABLED_ConsoleMessage
 #else
 #define MAYBE_ConsoleMessage ConsoleMessage
 #endif
 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_ConsoleMessage) {
   ASSERT_TRUE(RunPlatformAppTestWithArg(
@@ skipping 343 matching lines @@
 IN_PROC_BROWSER_TEST_F(WebViewTest, AllowTransparencyAndAllowScalingPropagate) {
   LoadAppWithGuest("web_view/simple");
 
   ASSERT_TRUE(!!GetGuestWebContents());
   extensions::WebViewGuest* guest =
       extensions::WebViewGuest::FromWebContents(GetGuestWebContents());
   ASSERT_TRUE(guest->allow_transparency());
   ASSERT_TRUE(guest->allow_scaling());
 }