Add Reload and LoadData methods to WebFrame.

chrome/renderer/render_view.cc

 // Copyright (c) 2009 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/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 82 matching lines @@
 #include "base/gfx/native_theme.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using webkit_glue::AutofillForm;
 using webkit_glue::PasswordForm;
 using webkit_glue::PasswordFormDomManager;
 using webkit_glue::SearchableFormData;
 using WebKit::WebConsoleMessage;
+using WebKit::WebData;
 using WebKit::WebDataSource;
 using WebKit::WebDragData;
 using WebKit::WebForm;
 using WebKit::WebHistoryItem;
 using WebKit::WebNavigationType;
 using WebKit::WebRect;
 using WebKit::WebScriptSource;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebURL;
@@ skipping 532 matching lines @@
   // initiated any load resulting from JS execution.
   if (!params.url.SchemeIs(chrome::kJavaScriptScheme)) {
     pending_navigation_state_.reset(NavigationState::CreateBrowserInitiated(
         params.page_id, params.transition, params.request_time));
   }
 
   // If we are reloading, then WebKit will use the history state of the current
   // page, so we should just ignore any given history state.  Otherwise, if we
   // have history state, then we need to navigate to it, which corresponds to a
   // back/forward navigation event.
-  if (!is_reload && !params.state.empty()) {
+  if (is_reload) {
+    main_frame->Reload();
+  } else if (!params.state.empty()) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(params.page_id, -1);
     main_frame->LoadHistoryItem(
         webkit_glue::HistoryItemFromString(params.state));
   } else {
     // Navigate to the given URL.
     WebURLRequest request(params.url);
 
-    // TODO(darin): WebFrame should just have a Reload method.
+    // A session history navigation should have been accompanied by state.
+    DCHECK_EQ(params.page_id, -1);
 
-    WebURLRequest::CachePolicy cache_policy;
-    if (is_reload) {
-      cache_policy = WebURLRequest::ReloadIgnoringCacheData;
-    } else {
-      // A session history navigation should have been accompanied by state.
-      DCHECK_EQ(params.page_id, -1);
-      if (main_frame->GetInViewSourceMode()) {
-        cache_policy = WebURLRequest::ReturnCacheDataElseLoad;
-      } else {
-        cache_policy = WebURLRequest::UseProtocolCachePolicy;
-      }
-    }
-    request.setCachePolicy(cache_policy);
+    if (main_frame->GetInViewSourceMode())
+      request.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad);
 
     if (params.referrer.is_valid()) {
       request.setHTTPHeaderField(WebString::fromUTF8("Referer"),
                                  WebString::fromUTF8(params.referrer.spec()));
     }
 
     main_frame->LoadRequest(request);
   }
 
   // In case LoadRequest failed before DidCreateDataSource was called.
   pending_navigation_state_.reset();
 }
 
 // Stop loading the current page
 void RenderView::OnStop() {
   if (webview())
     webview()->StopLoading();
 }
 
-void RenderView::OnLoadAlternateHTMLText(const std::string& html_contents,
+void RenderView::OnLoadAlternateHTMLText(const std::string& html,
                                          bool new_navigation,
                                          const GURL& display_url,
                                          const std::string& security_info) {
   if (!webview())
     return;
 
-  WebURLRequest request;
-  request.initialize();
-  request.setURL(GURL(kUnreachableWebDataURL));
-  request.setSecurityInfo(security_info);
+  pending_navigation_state_.reset(NavigationState::CreateBrowserInitiated(
+      new_navigation ? -1 : page_id_, PageTransition::LINK, Time::Now()));
+  pending_navigation_state_->set_security_info(security_info);
 
-  webview()->GetMainFrame()->LoadAlternateHTMLString(request,
-                                                     html_contents,
-                                                     display_url,
-                                                     !new_navigation);
+  webview()->GetMainFrame()->LoadHTMLString(html,
+                                            GURL(kUnreachableWebDataURL),
+                                            display_url,
+                                            !new_navigation);
+
+  pending_navigation_state_.reset();
 }
 
 void RenderView::OnCopyImageAt(int x, int y) {
   webview()->CopyImageAt(x, y);
 }
 
 void RenderView::OnExecuteEditCommand(const std::string& name,
     const std::string& value) {
   if (!webview() || !webview()->GetFocusedFrame())
     return;
@@ skipping 121 matching lines @@
   const WebURLResponse& response = ds->response();
 
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
 
   ViewHostMsg_FrameNavigate_Params params;
   params.http_status_code = response.httpStatusCode();
   params.is_post = false;
   params.page_id = page_id_;
   params.is_content_filtered = response.isContentFiltered();
-  if (!request.securityInfo().isEmpty()) {
+  if (!navigation_state->security_info().empty()) {
     // SSL state specified in the request takes precedence over the one in the
     // response.
     // So far this is only intended for error pages that are not expected to be
     // over ssl, so we should not get any clash.
     DCHECK(response.securityInfo().isEmpty());
-    params.security_info = request.securityInfo();
+    params.security_info = navigation_state->security_info();
   } else {
     params.security_info = response.securityInfo();
   }
 
   // Set the URL to be displayed in the browser UI to the user.
   if (ds->hasUnreachableURL()) {
     params.url = ds->unreachableURL();
   } else {
     params.url = request.url();
   }
@@ skipping 372 matching lines @@
     }
     error_strings.SetString(L"textdirection",
       (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT) ?
        L"rtl" : L"ltr");
 
     alt_html = GetAltHTMLForTemplate(error_strings, resource_id);
   } else {
     alt_html = html;
   }
 
-  // Use a data: URL as the site URL to prevent against XSS attacks.
-  WebURLRequest request(failed_request);
-  request.setURL(GURL(kUnreachableWebDataURL));
-
-  frame->LoadAlternateHTMLString(request, alt_html, failed_url, replace);
+  frame->LoadHTMLString(alt_html,
+                        GURL(kUnreachableWebDataURL),
+                        failed_url,
+                        replace);
 }
 
 void RenderView::DidCommitLoadForFrame(WebView *webview, WebFrame* frame,
                                        bool is_new_navigation) {
   NavigationState* navigation_state =
       NavigationState::FromDataSource(frame->GetDataSource());
 
   navigation_state->set_commit_load_time(Time::Now());
   if (is_new_navigation) {
     // When we perform a new navigation, we need to update the previous session
@@ skipping 1708 matching lines @@
     Send(new ViewHostMsg_PasswordFormsSeen(routing_id_, password_forms));
 }
 
 void RenderView::Print(WebFrame* frame, bool script_initiated) {
   DCHECK(frame);
   if (print_helper_.get() == NULL) {
     print_helper_.reset(new PrintWebViewHelper(this));
   }
   print_helper_->Print(frame, script_initiated);
 }