Plumb network stack information about existence of cached copy

content/renderer/render_view_browsertest.cc

Index: content/renderer/render_view_browsertest.cc
diff --git a/content/renderer/render_view_browsertest.cc b/content/renderer/render_view_browsertest.cc
index 7ffa3fa224bdf5fc290403450f776f3d1c7a39ab..a94081590418142646fc295b38286c8b6a1f5e31 100644
--- a/content/renderer/render_view_browsertest.cc
+++ b/content/renderer/render_view_browsertest.cc
@@ -4,28 +4,48 @@
 
 #include "base/basictypes.h"
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/view_messages.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/native_web_keyboard_event.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/bindings_policy.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/history_item_serialization.h"
 #include "content/public/renderer/navigation_state.h"
+#include "content/public/test/browser_test_utils.h"
 #include "content/public/test/render_view_test.h"
+#include "content/public/test/test_utils.h"
 #include "content/renderer/render_view_impl.h"
+#include "content/shell/browser/shell.h"
+#include "content/shell/browser/shell_browser_context.h"
 #include "content/shell/browser/shell_content_browser_client.h"
 #include "content/shell/common/shell_content_client.h"
+#include "content/shell/renderer/shell_content_renderer_client.h"
+#include "content/test/content_browser_test.h"
+#include "content/test/content_browser_test_utils.h"
 #include "content/test/mock_keyboard.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_status_flags.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/http/failing_http_transaction_factory.h"
+#include "net/http/http_cache.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebHTTPBody.h"
@@ -117,8 +137,6 @@ class WebUITestWebUIControllerFactory : public WebUIControllerFactory {
   }
 };
 
-}  // namespace
-
 class RenderViewImplTest : public RenderViewTest {
  public:
   RenderViewImplTest() {
@@ -304,6 +322,99 @@ class RenderViewImplTest : public RenderViewTest {
   scoped_ptr<MockKeyboard> mock_keyboard_;
 };
 
+class TestShellContentRendererClient : public ShellContentRendererClient {
+ public:
+  TestShellContentRendererClient()
+      : latest_error_valid_(false),
+        latest_error_reason_(0),
+        latest_error_stale_copy_in_cache_(false) {}
+
+  virtual void GetNavigationErrorStrings(
+      content::RenderView* render_view,
+      blink::WebFrame* frame,
+      const blink::WebURLRequest& failed_request,
+      const blink::WebURLError& error,
+      std::string* error_html,
+      base::string16* error_description) OVERRIDE {
+    if (error_html)
+      *error_html = "A suffusion of yellow.";
+    latest_error_valid_ = true;
+    latest_error_reason_ = error.reason;
+    latest_error_stale_copy_in_cache_ = error.staleCopyInCache;
+  }
+
+  bool GetLatestError(int* error_code, bool* stale_cache_entry_present) {
+    if (latest_error_valid_) {
+      *error_code = latest_error_reason_;
+      *stale_cache_entry_present = latest_error_stale_copy_in_cache_;
+    }
+    return latest_error_valid_;
+  }
+
+ private:
+  bool latest_error_valid_;
+  int latest_error_reason_;
+  bool latest_error_stale_copy_in_cache_;
+};
+
+// Must be called on IO thread.
+void InterceptNetworkTransactions(net::URLRequestContextGetter* getter,
+                                  net::Error error) {
+  DCHECK(content::BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::HttpCache* cache(
+      getter->GetURLRequestContext()->http_transaction_factory()->GetCache());
+  DCHECK(cache);
+  scoped_ptr<net::FailingHttpTransactionFactory> factory(
+      new net::FailingHttpTransactionFactory(cache->GetSession(), error));
+  // Throw away old version; since this is a browser test, there is no
+  // need to restore the old state.
+  cache->SetHttpNetworkTransactionFactoryForTesting(
+      factory.PassAs<net::HttpTransactionFactory>());
+}
+
+void CallOnUIThreadValidatingReturn(const base::Closure& callback,
+                                    int rv) {
+  DCHECK_EQ(net::OK, rv);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE, callback);
+}
+
+// Must be called on IO thread.  The callback will be called on
+// completion of cache clearing on the UI thread.
+void BackendClearCache(scoped_ptr<disk_cache::Backend*> backend,
+                       const base::Closure& callback,
+                       int rv) {
+  DCHECK(*backend);
+  DCHECK_EQ(net::OK, rv);
+  (*backend)->DoomAllEntries(
+      base::Bind(&CallOnUIThreadValidatingReturn, callback));
+}
+
+// Must be called on IO thread.  The callback will be called on
+// completion of cache clearing on the UI thread.
+void ClearCache(net::URLRequestContextGetter* getter,
+                const base::Closure& callback) {
+  DCHECK(content::BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::HttpCache* cache(
+      getter->GetURLRequestContext()->http_transaction_factory()->GetCache());
+  DCHECK(cache);
+  scoped_ptr<disk_cache::Backend*> backend(new disk_cache::Backend*);
+  *backend = NULL;
+  disk_cache::Backend** backend_ptr = backend.get();
+
+  net::CompletionCallback backend_callback(
+      base::Bind(&BackendClearCache, base::Passed(backend.Pass()), callback));
+
+  // backend_ptr is valid until all copies of backend_callback go out
+  // of scope.
+  if (net::OK == cache->GetBackend(backend_ptr, backend_callback)) {
+    // The call completed synchronously, so GetBackend didn't run the callback.
+    backend_callback.Run(net::OK);
+  }
+}
+
+}  // namespace
+
 // Test that we get form state change notifications when input fields change.
 TEST_F(RenderViewImplTest, DISABLED_OnNavStateChanged) {
   // Don't want any delay for form state sync changes. This will still post a
@@ -2240,4 +2351,114 @@ TEST_F(RenderViewImplTest, FocusElementCallsFocusedNodeChanged) {
   render_thread_->sink().ClearMessages();
 }
 
+// For actual, browser side tests targetting code in RenderView
+// or RenderViewImpl.
+class RenderViewBrowserTest : public ContentBrowserTest {
+ public:
+  RenderViewBrowserTest() : renderer_client_(NULL) {}
+
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    // This method is needed to allow interaction with in-process renderer
+    // and use of a test ContentRendererClient.
+    command_line->AppendSwitch(switches::kSingleProcess);
+  }
+
+  virtual void SetUp() OVERRIDE {
+    // Override setting of renderer client.
+    renderer_client_ = new TestShellContentRendererClient();
+    SetContentRendererClient(

[jam, 2014/01/30 18:49:27]

I think we can avoid the contentbrowsertest changes. You can call
ContentBrowserTest::Setup first, and then call SetRendererClientForTesting
directly here?

[Randy Smith (Not in Mondays), 2014/01/30 19:10:47]

ContentBrowserTest::SetUp() calls BrowserTestBase::SetUp(), which calls
BrowserMain().  So nothing you do after calling ContentBrowserTest::SetUp()
matters; the test will have run.  

I looked into doing setup/teardown at the beginning and end of the test, but the
constructor for ShellContentRendererClient DCHECKs if something is already
present in g_renderer_client and assigns itself to that value.  If I respect
that (which I'm tempted not too--setting oneself to a global variable inside
ones own constructor?--but it's not my code), that means we can only construct a
single instance of the content renderer client.  So that needs to be constructed
and assigned before ContentBrowserTest::SetUp(), which I think means changes to
ContentBrowserTest::SetUp().  

But if you have an alternative I'm not seeing, I'm up for it.

[jam, 2014/01/30 19:27:18]

ah I see. How about we change ContentBrowserTest to not create a
ContentRendererClient if it finds ContentClient::get()->renderer() is set
already? that should be a simpler change

[Randy Smith (Not in Mondays), 2014/01/30 22:03:48]

So that interface doesn't exist, at least as far as my eyes and compilation
found.  There is GetContentClient(), but that appears to be only defined #if
defined(CONTENT_IMPLEMENTATION), and it looks to me like content_tests.gypi
#undef that define.  So I don't see a way to probe g_client->renderer_ from
content_browser_test.cc.  Am I missing a pathway in?

+        scoped_ptr<ContentRendererClient>(renderer_client_).Pass());
+
+    ContentBrowserTest::SetUp();
+  }
+
+  // Navigates to the given URL and waits for |num_navigations| to occur, and
+  // the title to change to |expected_title|.
+  void NavigateToURLAndWaitForTitle(const GURL& url,
+                                    const std::string& expected_title,
+                                    int num_navigations) {
+    content::TitleWatcher title_watcher(
+        shell()->web_contents(), base::ASCIIToUTF16(expected_title));
+
+    content::NavigateToURLBlockUntilNavigationsComplete(
+        shell(), url, num_navigations);
+
+    EXPECT_EQ(base::ASCIIToUTF16(expected_title),
+              title_watcher.WaitAndGetTitle());
+  }
+
+  // Returns true if there is a valid error stored; in this case
+  // |*error_code| and |*stale_cache_entry_present| will be updated
+  // appropriately.
+  // Must be called after the renderer thread is created.
+  bool GetLatestErrorFromRendererClient(
+      int* error_code, bool* stale_cache_entry_present) {
+    bool result = false;
+
+    PostTaskToInProcessRendererAndWait(
+        base::Bind(&RenderViewBrowserTest::GetLatestErrorFromRendererClient0,
+                   renderer_client_, &result, error_code,
+                   stale_cache_entry_present));
+    return result;
+  }
+
+ private:
+  // Must be run on renderer thread.
+  static void GetLatestErrorFromRendererClient0(
+      TestShellContentRendererClient* renderer_client,
+      bool* result, int* error_code, bool* stale_cache_entry_present) {
+    *result = renderer_client->GetLatestError(
+        error_code, stale_cache_entry_present);
+  }
+
+  // Actually owned by the superclass, so safe to keep a bare pointer.
+  TestShellContentRendererClient* renderer_client_;
+};
+
+IN_PROC_BROWSER_TEST_F(RenderViewBrowserTest, ConfirmCacheInformationPlumbed) {
+  ASSERT_TRUE(test_server()->Start());
+
+  // Load URL with "nocache" set, to create stale cache.
+  GURL test_url(test_server()->GetURL("files/nocache.html"));
+  NavigateToURLAndWaitForTitle(test_url, "Nocache Test Page", 1);
+
+  // Reload same URL after forcing an error from the the network layer;
+  // confirm that the error page is told the cached copy exists.
+  int renderer_id =
+      shell()->web_contents()->GetMainFrame()->GetProcess()->GetID();
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
+      ShellContentBrowserClient::Get()->browser_context()->
+          GetRequestContextForRenderProcess(renderer_id);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&InterceptNetworkTransactions, url_request_context_getter,
+                 net::ERR_FAILED));
+
+  // An error results in one completed navigation.
+  content::NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
+  int error_code = net::OK;
+  bool stale_cache_entry_present = false;
+  ASSERT_TRUE(GetLatestErrorFromRendererClient(
+      &error_code, &stale_cache_entry_present));
+  EXPECT_EQ(net::ERR_FAILED, error_code);
+  EXPECT_TRUE(stale_cache_entry_present);
+
+  // Clear the cache and repeat; confirm lack of entry in cache reported.
+  scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearCache, url_request_context_getter,
+                 runner->QuitClosure()));
+  runner->Run();
+
+  content::NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
+
+  error_code = net::OK;
+  stale_cache_entry_present = true;
+  ASSERT_TRUE(GetLatestErrorFromRendererClient(
+      &error_code, &stale_cache_entry_present));
+  EXPECT_EQ(net::ERR_FAILED, error_code);
+  EXPECT_FALSE(stale_cache_entry_present);
+}
+
 }  // namespace content