/* * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com) * Copyright (C) 2006 Apple Computer, Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ // How ownership works // ------------------- // // Big oh represents a refcounted relationship: owner O--- ownee // // WebView (for the toplevel frame only) // O // | // O // WebFrame <-------------------------- FrameLoader // O (via WebFrameLoaderClient) || // | || // +------------------------------+ || // | || // FrameView O-------------------------O Frame // // FrameLoader and Frame are formerly one object that was split apart because // it got too big. They basically have the same lifetime, hence the double line. // // WebFrame is refcounted and has one ref on behalf of the FrameLoader/Frame // and, in the case of the toplevel frame, one more for the WebView. This is // not a normal reference counted pointer because that would require changing // WebKit code that we don't control. Instead, it is created with this ref // initially and it is removed when the FrameLoader is getting destroyed. // // WebFrames are created in two places, first in WebViewImpl when the root // frame is created, and second in WebFrame::CreateChildFrame when sub-frames // are created. WebKit will hook up this object to the FrameLoader/Frame // and the refcount will be correct. // // How frames are destroyed // ------------------------ // // The main frame is never destroyed and is re-used. The FrameLoader is // re-used and a reference is also kept by the WebView, so the root frame will // generally have a refcount of 2. // // When frame content is replaced, all subframes are destroyed. This happens // in FrameLoader::detachFromParent for each suframe. Here, we first clear // the view in the Frame, breaking the circular cycle between Frame and // FrameView. Then it calls detachedFromParent4 on the FrameLoaderClient. // // The FrameLoaderClient is implemented by WebFrameLoaderClient, which is // an object owned by WebFrame. It calls WebFrame::Closing which causes // WebFrame to release its references to Frame, generally releasing it. // // Frame going away causes the FrameLoader to get deleted. In FrameLoader's // destructor it notifies its client with frameLoaderDestroyed. This derefs // WebView and will cause it to be deleted (unless an external someone is also // holding a reference). #include "config.h" #include "build/build_config.h" #include #include #pragma warning(push, 0) #include "HTMLFormElement.h" // need this before Document.h #include "Chrome.h" #include "Console.h" #include "Document.h" #include "DocumentFragment.h" // Only needed for ReplaceSelectionCommand.h :( #include "DocumentLoader.h" #include "DOMWindow.h" #include "Editor.h" #include "EventHandler.h" #include "Frame.h" #include "FrameLoader.h" #include "FrameLoadRequest.h" #include "FrameTree.h" #include "FrameView.h" #include "FrameWin.h" #include "GraphicsContext.h" #include "HTMLHeadElement.h" #include "HTMLLinkElement.h" #include "HTMLNames.h" #include "HistoryItem.h" #include "markup.h" #include "Page.h" #include "PlatformScrollBar.h" #include "RenderFrame.h" #include "RenderWidget.h" #include "ReplaceSelectionCommand.h" #include "ResourceHandle.h" #if defined(OS_WIN) #include "ResourceHandleWin.h" #endif #include "ResourceRequest.h" #include "ScriptController.h" #include "SelectionController.h" #include "Settings.h" #include "SkiaUtils.h" #include "SubstituteData.h" #include "TextIterator.h" #include "TextAffinity.h" #include "XPathResult.h" #pragma warning(pop) #undef LOG #include "base/gfx/bitmap_platform_device.h" #include "base/gfx/platform_canvas.h" #include "base/gfx/rect.h" #include "base/logging.h" #include "base/message_loop.h" #include "base/stats_counters.h" #include "base/string_util.h" #include "base/time.h" #include "net/base/net_errors.h" #include "webkit/glue/dom_operations.h" #include "webkit/glue/glue_serialize.h" #include "webkit/glue/alt_error_page_resource_fetcher.h" #include "webkit/glue/webdocumentloader_impl.h" #include "webkit/glue/weberror_impl.h" #include "webkit/glue/webframe_impl.h" #include "webkit/glue/webhistoryitem_impl.h" #include "webkit/glue/webtextinput_impl.h" #include "webkit/glue/webview_impl.h" #include "webkit/port/page/ChromeClientWin.h" #include "webkit/port/platform/WidgetClientWin.h" using WebCore::ChromeClientWin; using WebCore::Color; using WebCore::Document; using WebCore::DocumentFragment; using WebCore::DocumentLoader; using WebCore::ExceptionCode; using WebCore::GraphicsContext; using WebCore::HTMLFrameOwnerElement; using WebCore::Frame; using WebCore::FrameLoader; using WebCore::FrameLoadRequest; using WebCore::FrameLoadType; using WebCore::FrameTree; using WebCore::FrameView; using WebCore::HistoryItem; using WebCore::HTMLFrameElementBase; using WebCore::IntRect; using WebCore::KURL; using WebCore::Node; using WebCore::PlatformScrollbar; using WebCore::Range; using WebCore::ReloadIgnoringCacheData; using WebCore::RenderObject; using WebCore::ResourceError; using WebCore::ResourceHandle; using WebCore::ResourceRequest; using WebCore::Selection; using WebCore::SharedBuffer; using WebCore::String; using WebCore::SubstituteData; using WebCore::TextIterator; using WebCore::VisiblePosition; using WebCore::WidgetClientWin; using WebCore::XPathResult; static const wchar_t* const kWebFrameActiveCount = L"WebFrameActiveCount"; static const char* const kOSDType = "application/opensearchdescription+xml"; static const char* const kOSDRel = "search"; // The separator between frames when the frames are converted to plain text. static const wchar_t kFrameSeparator[] = L"\n\n"; static const int kFrameSeparatorLen = arraysize(kFrameSeparator) - 1; // Backend for GetContentAsPlainText, this is a recursive function that gets // the text for the current frame and all of its subframes. It will append // the text of each frame in turn to the |output| up to |max_chars| length. // // The |frame| must be non-NULL. static void FrameContentAsPlainText(int max_chars, Frame* frame, std::wstring* output) { Document* doc = frame->document(); if (!doc) return; // Select the document body. RefPtr range(doc->createRange()); ExceptionCode exception = 0; range->selectNodeContents(doc->body(), exception); if (exception == 0) { // The text iterator will walk nodes giving us text. This is similar to // the plainText() function in TextIterator.h, but we implement the maximum // size and also copy the results directly into a wstring, avoiding the // string conversion. for (TextIterator it(range.get()); !it.atEnd(); it.advance()) { const wchar_t* chars = reinterpret_cast(it.characters()); if (!chars) { if (it.length() != 0) { // It appears from crash reports that an iterator can get into a state // where the character count is nonempty but the character pointer is // NULL. advance()ing it will then just add that many to the NULL // pointer which won't be caught in a NULL check but will crash. // // A NULL pointer and 0 length is common for some nodes. // // IF YOU CATCH THIS IN A DEBUGGER please let brettw know. We don't // currently understand the conditions for this to occur. Ideally, the // iterators would never get into the condition so we should fix them // if we can. NOTREACHED(); break; } // Just got a NULL node, we can forge ahead! continue; } int to_append = std::min(it.length(), max_chars - static_cast(output->size())); output->append(chars, to_append); if (output->size() >= static_cast(max_chars)) return; // Filled up the buffer. } } // Recursively walk the children. FrameTree* frame_tree = frame->tree(); Frame* cur_child = frame_tree->firstChild(); for (Frame* cur_child = frame_tree->firstChild(); cur_child; cur_child = cur_child->tree()->nextSibling()) { // Make sure the frame separator won't fill up the buffer, and give up if // it will. The danger is if the separator will make the buffer longer than // max_chars. This will cause the computation above: // max_chars - output->size() // to be a negative number which will crash when the subframe is added. if (static_cast(output->size()) >= max_chars - kFrameSeparatorLen) return; output->append(kFrameSeparator, kFrameSeparatorLen); FrameContentAsPlainText(max_chars, cur_child, output); if (output->size() >= static_cast(max_chars)) return; // Filled up the buffer. } } // WebFrameImpl ---------------------------------------------------------------- int WebFrameImpl::live_object_count_ = 0; WebFrameImpl::WebFrameImpl() // Don't complain about using "this" in initializer list. MSVC_PUSH_DISABLE_WARNING(4355) : frame_loader_client_(this), scope_matches_factory_(this), MSVC_POP_WARNING() currently_loading_request_(NULL), plugin_delegate_(NULL), allows_scrolling_(true), margin_width_(-1), margin_height_(-1), last_match_count_(-1), total_matchcount_(-1), inspected_node_(NULL), active_tickmark_frame_(NULL), active_tickmark_(WidgetClientWin::kNoTickmark), locating_active_rect_(false), last_active_range_(NULL), frames_scoping_count_(-1), scoping_complete_(false), next_invalidate_after_(0), printing_(false) { StatsCounter(kWebFrameActiveCount).Increment(); live_object_count_++; } WebFrameImpl::~WebFrameImpl() { StatsCounter(kWebFrameActiveCount).Decrement(); live_object_count_--; CancelPendingScopingEffort(); } // WebFrame ------------------------------------------------------------------- void WebFrameImpl::InitMainFrame(WebViewImpl* webview_impl) { webview_impl_ = webview_impl; // owning ref frame_ = Frame::create(webview_impl_->page(), 0, &frame_loader_client_); // Add reference on behalf of FrameLoader. See comments in // WebFrameLoaderClient::frameLoaderDestroyed for more info. AddRef(); // We must call init() after frame_ is assigned because it is referenced // during init(). frame_->init(); } void WebFrameImpl::LoadRequest(WebRequest* request) { SubstituteData data; InternalLoadRequest(request, data, false); } void WebFrameImpl::InternalLoadRequest(const WebRequest* request, const SubstituteData& data, bool replace) { const WebRequestImpl* request_impl = static_cast(request); const ResourceRequest& resource_request = request_impl->frame_load_request().resourceRequest(); // Special-case javascript URLs. Do not interrupt the existing load when // asked to load a javascript URL unless the script generates a result. // We can't just use FrameLoader::executeIfJavaScriptURL because it doesn't // handle redirects properly. const KURL& kurl = resource_request.url(); if (!data.isValid() && kurl.protocol() == "javascript") { // Don't attempt to reload javascript URLs. if (resource_request.cachePolicy() == ReloadIgnoringCacheData) return; // We can't load a javascript: URL if there is no Document! if (!frame_->document()) return; // TODO(darin): Is this the best API to use here? It works and seems good, // but will it change out from under us? String script = decodeURLEscapeSequences(kurl.string().substring(sizeof("javascript:")-1)); bool succ = false; String value = frame_->loader()->executeScript(script, &succ, true); if (succ && !frame_->loader()->isScheduledLocationChangePending()) { // TODO(darin): We need to figure out how to represent this in session // history. Hint: don't re-eval script when the user or script navigates // back-n-forth (instead store the script result somewhere). LoadDocumentData(kurl, value, String("text/html"), String()); } return; } StopLoading(); // make sure existing activity stops // Keep track of the request temporarily. This is effectively a way of // passing the request to callbacks that may need it. See // WebFrameLoaderClient::createDocumentLoader. currently_loading_request_ = request; // If we have a current datasource, save the request info on it immediately. // This is because WebCore may not actually initiate a load on the toplevel // frame for some subframe navigations, so we want to update its request. WebDataSourceImpl* datasource = GetDataSourceImpl(); if (datasource) CacheCurrentRequestInfo(datasource); if (data.isValid()) { frame_->loader()->load(resource_request, data); if (replace) { // Do this to force WebKit to treat the load as replacing the currently // loaded page. frame_->loader()->setReplacing(); } } else if (request_impl->history_item()) { // Use the history item if we have one, otherwise fall back to standard // load. RefPtr current_item = frame_->loader()->currentHistoryItem(); // If there is no current_item, which happens when we are navigating in // session history after a crash, we need to manufacture one otherwise // WebKit hoarks. This is probably the wrong thing to do, but it seems to // work. if (!current_item) { current_item = HistoryItem::create(); frame_->loader()->setCurrentHistoryItem(current_item); frame_->page()->backForwardList()->setCurrentItem(current_item.get()); // Mark the item as fake, so that we don't attempt to save its state and // end up with about:blank in the navigation history. frame_->page()->backForwardList()->setCurrentItemFake(true); } frame_->loader()->goToItem(request_impl->history_item().get(), WebCore::FrameLoadTypeIndexedBackForward); } else if (resource_request.cachePolicy() == ReloadIgnoringCacheData) { frame_->loader()->reload(); } else { frame_->loader()->load(resource_request); } currently_loading_request_ = NULL; } void WebFrameImpl::LoadHTMLString(const std::string& html_text, const GURL& base_url) { WebRequestImpl request(base_url); LoadAlternateHTMLString(&request, html_text, GURL(), false); } void WebFrameImpl::LoadAlternateHTMLString(const WebRequest* request, const std::string& html_text, const GURL& display_url, bool replace) { int len = static_cast(html_text.size()); RefPtr buf = SharedBuffer::create(html_text.data(), len); SubstituteData subst_data( buf, String("text/html"), String("UTF-8"), webkit_glue::GURLToKURL(display_url)); DCHECK(subst_data.isValid()); InternalLoadRequest(request, subst_data, replace); } GURL WebFrameImpl::GetURL() const { const WebDataSource* ds = GetDataSource(); if (!ds) return GURL(); return ds->GetRequest().GetURL(); } GURL WebFrameImpl::GetFavIconURL() const { WebCore::FrameLoader* frame_loader = frame_->loader(); // The URL to the favicon may be in the header. As such, only // ask the loader for the favicon if it's finished loading. if (frame_loader->state() == WebCore::FrameStateComplete) { const KURL& url = frame_loader->iconURL(); if (!url.isEmpty()) { return webkit_glue::KURLToGURL(url); } } return GURL(); } GURL WebFrameImpl::GetOSDDURL() const { WebCore::FrameLoader* frame_loader = frame_->loader(); if (frame_loader->state() == WebCore::FrameStateComplete && frame_->document() && frame_->document()->head() && !frame_->tree()->parent()) { WebCore::HTMLHeadElement* head = frame_->document()->head(); if (head) { RefPtr children = head->children(); for (Node* child = children->firstItem(); child != NULL; child = children->nextItem()) { WebCore::HTMLLinkElement* link_element = webkit_glue::CastHTMLElement( child, WebCore::HTMLNames::linkTag); if (link_element && link_element->type() == kOSDType && link_element->rel() == kOSDRel && !link_element->href().isEmpty()) { return webkit_glue::KURLToGURL(link_element->href()); } } } } return GURL(); } bool WebFrameImpl::GetPreviousState(GURL* url, std::wstring* title, std::string* history_state) const { // We use the previous item here because documentState (filled-out forms) // only get saved to history when it becomes the previous item. The caller // is expected to query the history state after a navigation occurs, after // the desired history item has become the previous entry. if (frame_->page()->backForwardList()->isPreviousItemFake()) return false; RefPtr item = frame_->page()->backForwardList()->previousItem(); if (!item) return false; static StatsCounterTimer history_timer(L"GetHistoryTimer"); StatsScope history_scope(history_timer); webkit_glue::HistoryItemToString(item, history_state); *url = webkit_glue::KURLToGURL(item->url()); *title = webkit_glue::StringToStdWString(item->title()); return true; } bool WebFrameImpl::GetCurrentState(GURL* url, std::wstring* title, std::string* state) const { if (frame_->loader()) frame_->loader()->saveDocumentAndScrollState(); RefPtr item = frame_->page()->backForwardList()->currentItem(); if (!item) return false; webkit_glue::HistoryItemToString(item, state); *url = webkit_glue::KURLToGURL(item->url()); *title = webkit_glue::StringToStdWString(item->title()); return true; } bool WebFrameImpl::HasCurrentState() const { return frame_->page()->backForwardList()->currentItem() != NULL; } void WebFrameImpl::LoadDocumentData(const KURL& base_url, const String& data, const String& mime_type, const String& charset) { // TODO(darin): This is wrong. We need to re-cast this in terms of a call to // one of the FrameLoader::load(...) methods. Else, WebCore will be angry!! // Requiring a base_url here seems like a good idea for security reasons. ASSERT(!base_url.isEmpty()); ASSERT(!mime_type.isEmpty()); StopLoading(); // Reset any pre-existing scroll offset frameview()->setContentsPos(0, 0); // Make sure the correct document type is constructed. frame_->loader()->setResponseMIMEType(mime_type); // TODO(darin): Inform the FrameLoader of the charset somehow. frame_->loader()->begin(base_url); frame_->loader()->write(data); frame_->loader()->end(); } void WebFrameImpl::set_currently_loading_history_item( WebHistoryItemImpl* item) { currently_loading_history_item_ = item; } static WebDataSource* DataSourceForDocLoader(DocumentLoader* loader) { return (loader ? static_cast(loader)->GetDataSource() : NULL); } WebDataSource* WebFrameImpl::GetDataSource() const { if (!frame_->loader()) return NULL; return DataSourceForDocLoader(frame_->loader()->documentLoader()); } WebDataSourceImpl* WebFrameImpl::GetDataSourceImpl() const { return static_cast(GetDataSource()); } WebDataSource* WebFrameImpl::GetProvisionalDataSource() const { FrameLoader* frame_loader = frame_->loader(); if (!frame_loader) return NULL; // We regard the policy document loader as still provisional. DocumentLoader* doc_loader = frame_loader->provisionalDocumentLoader(); if (!doc_loader) doc_loader = frame_loader->policyDocumentLoader(); return DataSourceForDocLoader(doc_loader); } WebDataSourceImpl* WebFrameImpl::GetProvisionalDataSourceImpl() const { return static_cast(GetProvisionalDataSource()); } void WebFrameImpl::CacheCurrentRequestInfo(WebDataSourceImpl* datasource) { // Cache our current request info on the data source. It contains its // own requests, so the extra data needs to be transferred. scoped_refptr extra; // Our extra data may come from a request issued via LoadRequest, or a // history navigation from WebCore. if (currently_loading_request_) { extra = currently_loading_request_->GetExtraData(); } else if (currently_loading_history_item_) { extra = currently_loading_history_item_->GetExtraData(); currently_loading_history_item_ = 0; } // We must only update this if it is valid, or the valid state will be lost. if (extra) datasource->SetExtraData(extra); } void WebFrameImpl::StopLoading() { if (!frame_) return; // TODO(darin): Figure out what we should really do here. It seems like a // bug that FrameLoader::stopLoading doesn't call stopAllLoaders. frame_->loader()->stopAllLoaders(); frame_->loader()->stopLoading(false); } WebFrame* WebFrameImpl::GetOpener() const { if (frame_) { Frame* opener = frame_->loader()->opener(); if (opener) return FromFrame(opener); } return NULL; } WebFrame* WebFrameImpl::GetParent() const { if (frame_) { Frame *parent = frame_->tree()->parent(); if (parent) return FromFrame(parent); } return NULL; } WebFrame* WebFrameImpl::GetChildFrame(const std::wstring& xpath) const { // xpath string can represent a frame deep down the tree (across multiple // frame DOMs). // Example, /html/body/table/tbody/tr/td/iframe\n/frameset/frame[0] // should break into 2 xpaths // /html/body/table/tbody/tr/td/iframe & /frameset/frame[0] if (xpath.empty()) return NULL; std::wstring secondary; String xpath_str; std::wstring::size_type delim_pos = xpath.find_first_of(L'\n'); if (delim_pos != std::wstring::npos) { std::wstring primary = xpath.substr(0, delim_pos); secondary = xpath.substr(delim_pos + 1); xpath_str = webkit_glue::StdWStringToString(primary); } else { xpath_str = webkit_glue::StdWStringToString(xpath); } Document* document = frame_->document(); ExceptionCode ec = 0; PassRefPtr xpath_result = document->evaluate(xpath_str, document, NULL, /* namespace */ XPathResult::ORDERED_NODE_ITERATOR_TYPE, NULL, /* XPathResult object */ ec); if (!xpath_result.get()) return NULL; Node* node = xpath_result->iterateNext(ec); if (!node || !node->isFrameOwnerElement()) return NULL; HTMLFrameOwnerElement* frame_element = static_cast(node); WebFrame* web_frame = FromFrame(frame_element->contentFrame()); if (secondary.empty()) return web_frame; else return web_frame->GetChildFrame(secondary); } void WebFrameImpl::SetInViewSourceMode(bool enable) { if (frame_) frame_->setInViewSourceMode(enable); } bool WebFrameImpl::GetInViewSourceMode() const { if (frame_) return frame_->inViewSourceMode(); return false; } WebView* WebFrameImpl::GetView() const { return webview_impl_; } void WebFrameImpl::BindToWindowObject(const std::wstring& name, NPObject* object) { assert(frame_); if (!frame_ || !frame_->script()->isEnabled()) return; String key = webkit_glue::StdWStringToString(name); frame_->script()->BindToWindowObject(frame_.get(), key, object); } // Call JavaScript garbage collection. void WebFrameImpl::CallJSGC() { if (!frame_) return; if (!frame_->settings()->isJavaScriptEnabled()) return; frame_->script()->collectGarbage(); } void WebFrameImpl::GetContentAsPlainText(int max_chars, std::wstring* text) const { text->clear(); if (!frame_) return; FrameContentAsPlainText(max_chars, frame_.get(), text); } void WebFrameImpl::InvalidateArea(AreaToInvalidate area) { ASSERT(frame() && frame()->view()); FrameView* view = frame()->view(); #if defined(OS_WIN) // TODO(pinkerton): Fix Mac invalidation to be more like Win ScrollView if ((area & INVALIDATE_ALL) == INVALIDATE_ALL) { view->addToDirtyRegion(view->frameGeometry()); } else { if ((area & INVALIDATE_CONTENT_AREA) == INVALIDATE_CONTENT_AREA) { IntRect content_area(view->x(), view->y(), view->visibleWidth(), view->visibleHeight()); view->addToDirtyRegion(content_area); } if ((area & INVALIDATE_SCROLLBAR) == INVALIDATE_SCROLLBAR) { // Invalidate the vertical scroll bar region for the view. IntRect scroll_bar_vert(view->x() + view->visibleWidth(), view->y(), PlatformScrollbar::verticalScrollbarWidth(), view->visibleHeight()); view->addToDirtyRegion(scroll_bar_vert); } } #endif } void WebFrameImpl::InvalidateTickmark(RefPtr tickmark) { ASSERT(frame() && frame()->view()); FrameView* view = frame()->view(); #if defined(OS_WIN) // TODO(pinkerton): Fix Mac invalidation to be more like Win ScrollView IntRect pos = tickmark->boundingBox(); pos.move(-view->contentsX(), -view->contentsY()); view->addToDirtyRegion(pos); #endif } void WebFrameImpl::IncreaseMatchCount(int count, int request_id) { total_matchcount_ += count; // Update the UI with the latest findings. WebViewDelegate* webview_delegate = GetView()->GetDelegate(); DCHECK(webview_delegate); if (webview_delegate) webview_delegate->ReportFindInPageMatchCount(total_matchcount_, request_id, frames_scoping_count_ == 0); } void WebFrameImpl::ReportFindInPageSelection(const gfx::Rect& selection_rect, int active_match_ordinal, int request_id) { // Update the UI with the latest selection rect. WebViewDelegate* webview_delegate = GetView()->GetDelegate(); DCHECK(webview_delegate); if (webview_delegate) { webview_delegate->ReportFindInPageSelection( request_id, OrdinalOfFirstMatchForFrame(this) + active_match_ordinal, selection_rect); } } void WebFrameImpl::ResetMatchCount() { total_matchcount_ = 0; frames_scoping_count_ = 0; } bool WebFrameImpl::Find(const FindInPageRequest& request, bool wrap_within_frame, gfx::Rect* selection_rect) { WebCore::String webcore_string = webkit_glue::StdWStringToString(request.search_string); // Starts the search from the current selection. bool start_in_selection = true; // Policy. Can it be made configurable? // If the user has selected something since the last Find operation we want // to start from there. Otherwise, we start searching from where the last Find // operation left off (either a Find or a FindNext operation). Selection selection(frame()->selection()->selection()); if (selection.isNone() && last_active_range_) { selection = Selection(last_active_range_.get()); frame()->selection()->setSelection(selection); } DCHECK(frame() && frame()->view()); bool found = frame()->findString(webcore_string, request.forward, request.match_case, wrap_within_frame, start_in_selection); // If we find something on the page, we'll need to have the scoping effort // locate it so that we can highlight it as active. locating_active_rect_ = found; if (found) { // Set this frame as the active frame (the one with the active tick-mark). WebFrameImpl* const main_frame_impl = static_cast(GetView()->GetMainFrame()); main_frame_impl->active_tickmark_frame_ = this; // We found something, so we can now query the selection for its position. Selection new_selection(frame()->selection()->selection()); // If we thought we found something, but it couldn't be selected (perhaps // because it was marked -webkit-user-select: none), we can't set it to // be active but we still continue searching. This matches Safari's // behavior, including some oddities when selectable and un-selectable text // are mixed on a page: see https://bugs.webkit.org/show_bug.cgi?id=19127. if (new_selection.isNone() || (new_selection.start() == new_selection.end())) { // The selection controller is not giving us a valid selection so we don't // know what the active rect is. The scoping effort should still continue, // in case there are other selectable matches on the page. Setting the // active_selection_rect to a default rect causes the scoping effort to // mark the first match it finds as active and continue scoping. active_selection_rect_ = IntRect(); last_active_range_ = new_selection.toRange(); *selection_rect = gfx::Rect(); } else { last_active_range_ = new_selection.toRange(); active_selection_rect_ = new_selection.toRange()->boundingBox(); ClearSelection(); // We'll draw our own highlight for the active item. #if defined(OS_WIN) // TODO(pinkerton): Fix Mac scrolling to be more like Win ScrollView if (selection_rect) { gfx::Rect rect( frame()->view()->convertToContainingWindow(active_selection_rect_)); rect.Offset(-frameview()->scrollOffset().width(), -frameview()->scrollOffset().height()); *selection_rect = rect; } #endif } } if (!found) { active_selection_rect_ = IntRect(); last_active_range_ = NULL; if (!tickmarks_.isEmpty()) { // Let the frame know that we found no matches. tickmarks_.clear(); // Erase all previous tickmarks and highlighting. InvalidateArea(INVALIDATE_ALL); } } return found; } bool WebFrameImpl::FindNext(const FindInPageRequest& request, bool wrap_within_frame) { if (tickmarks_.isEmpty()) return false; // Save the old tickmark (if any). We will use this to invalidate the area // of the tickmark that becomes unselected. WebFrameImpl* const main_frame_impl = static_cast(GetView()->GetMainFrame()); WebFrameImpl* const active_frame = main_frame_impl->active_tickmark_frame_; RefPtr old_tickmark = NULL; if (active_frame && (active_frame->active_tickmark_ != WidgetClientWin::kNoTickmark)) { // When we get a reference to |old_tickmark| we can be in a state where // the |active_tickmark_| points outside the tickmark vector, possibly // during teardown of the frame. This doesn't reproduce normally, so if you // hit this during debugging, update issue http://b/1277569 with // reproduction steps - or contact the assignee. In release, we can ignore // this and continue on (and let |old_tickmark| be null). if (active_frame->active_tickmark_ >= active_frame->tickmarks_.size()) NOTREACHED() << L"Active tickmark points outside the tickmark vector!"; else old_tickmark = active_frame->tickmarks_[active_frame->active_tickmark_]; } // See if we have another match to select, and select it. if (request.forward) { const bool at_end = (active_tickmark_ == (tickmarks_.size() - 1)); if ((active_tickmark_ == WidgetClientWin::kNoTickmark) || (at_end && wrap_within_frame)) { // Wrapping within a frame is only done for single frame pages. So when we // reach the end we go back to the beginning (or back to the end if // searching backwards). active_tickmark_ = 0; } else if (at_end) { return false; } else { ++active_tickmark_; DCHECK(active_tickmark_ < tickmarks_.size()); } } else { const bool at_end = (active_tickmark_ == 0); if ((active_tickmark_ == WidgetClientWin::kNoTickmark) || (at_end && wrap_within_frame)) { // Wrapping within a frame is not done for multi-frame pages, but if no // tickmark is active we still need to set the index to the end so that // we don't skip the frame during FindNext when searching backwards. active_tickmark_ = tickmarks_.size() - 1; } else if (at_end) { return false; } else { --active_tickmark_; DCHECK(active_tickmark_ < tickmarks_.size()); } } if (active_frame != this) { // If we are jumping between frames, reset the active tickmark in the old // frame and invalidate the area. active_frame->active_tickmark_ = WidgetClientWin::kNoTickmark; active_frame->InvalidateArea(INVALIDATE_CONTENT_AREA); main_frame_impl->active_tickmark_frame_ = this; } else { // Invalidate the old tickmark. if (old_tickmark) active_frame->InvalidateTickmark(old_tickmark); } Selection selection(tickmarks_[active_tickmark_].get()); frame()->selection()->setSelection(selection); frame()->revealSelection(); // Scroll the selection into view if necessary. // Make sure we save where the selection was after the operation so that // we can set the selection to it for the next Find operation (if needed). last_active_range_ = tickmarks_[active_tickmark_]; ClearSelection(); // We will draw our own highlighting. #if defined(OS_WIN) // TODO(pinkerton): Fix Mac invalidation to be more like Win ScrollView // Notify browser of new location for the selected rectangle. IntRect pos = tickmarks_[active_tickmark_]->boundingBox(); pos.move(-frameview()->scrollOffset().width(), -frameview()->scrollOffset().height()); ReportFindInPageSelection( gfx::Rect(frame()->view()->convertToContainingWindow(pos)), active_tickmark_ + 1, request.request_id); #endif return true; // Found a match. } int WebFrameImpl::OrdinalOfFirstMatchForFrame(WebFrameImpl* frame) const { int ordinal = 0; WebFrameImpl* const main_frame_impl = static_cast(GetView()->GetMainFrame()); // Iterate from the main frame up to (but not including) this frame and // add up the number of tickmarks. for (WebFrameImpl* frame = main_frame_impl; frame != this; frame = static_cast( webview_impl_->GetNextFrameAfter(frame, true))) { ordinal += frame->tickmarks().size(); } return ordinal; } bool WebFrameImpl::ShouldScopeMatches(FindInPageRequest request) { // Don't scope if we can't find a frame or if the frame is not visible. // The user may have closed the tab/application, so abort. if (!frame() || !Visible()) return false; DCHECK(frame()->document() && frame()->view()); // If the frame completed the scoping operation and found 0 matches the last // time it was searched, then we don't have to search it again if the user is // just adding to the search string or sending the same search string again. if (scoping_complete_ && last_search_string_ != std::wstring(L"") && last_match_count_ == 0) { // Check to see if the search string prefixes match. std::wstring previous_search_prefix = request.search_string.substr(0, last_search_string_.length()); if (previous_search_prefix == last_search_string_) { return false; // Don't search this frame, it will be fruitless. } } return true; } void WebFrameImpl::InvalidateIfNecessary() { if (last_match_count_ > next_invalidate_after_) { // TODO(finnur): (http://b/1088165) Optimize the drawing of the // tickmarks and remove this. This calculation sets a milestone for when // next to invalidate the scrollbar and the content area. We do this so that // we don't spend too much time drawing the scrollbar over and over again. // Basically, up until the first 500 matches there is no throttle. After the // first 500 matches, we set set the milestone further and further out (750, // 1125, 1688, 2K, 3K). static const int start_slowing_down_after = 500; static const int slowdown = 750; int i = (last_match_count_ / start_slowing_down_after); next_invalidate_after_ += i * slowdown; // Invalidating content area draws both highlighting and in-page // tickmarks, but not the scrollbar. // TODO(finnur): (http://b/1088165) invalidate content area only if // match found on-screen. InvalidateArea(INVALIDATE_CONTENT_AREA); InvalidateArea(INVALIDATE_SCROLLBAR); } } // static bool WebFrameImpl::RangeShouldBeHighlighted(Range* range) { ExceptionCode exception = 0; Node* common_ancestor_container = range->commonAncestorContainer(exception); if (exception) return false; RenderObject* renderer = common_ancestor_container->renderer(); if (!renderer) return false; IntRect overflow_clip_rect = renderer->absoluteClippedOverflowRect(); return range->boundingBox().intersects(overflow_clip_rect); } void WebFrameImpl::selectNodeFromInspector(WebCore::Node* node) { inspected_node_ = node; } void WebFrameImpl::ScopeStringMatches(FindInPageRequest request, bool reset) { if (!ShouldScopeMatches(request)) return; WebFrameImpl* main_frame_impl = static_cast(GetView()->GetMainFrame()); if (reset) { // This is a brand new search, so we need to reset everything. // Scoping is just about to begin. scoping_complete_ = false; // First of all, all previous tickmarks need to be erased. tickmarks_.clear(); // Clear the counters from last operation. last_match_count_ = 0; next_invalidate_after_ = 0; main_frame_impl->frames_scoping_count_++; // Now, defer scoping until later to allow find operation to finish quickly. MessageLoop::current()->PostTask(FROM_HERE, scope_matches_factory_.NewRunnableMethod( &WebFrameImpl::ScopeStringMatches, request, false)); // false=we just reset, so don't do it again. return; } WebCore::String webcore_string = webkit_glue::StdWStringToString(request.search_string); RefPtr searchRange(rangeOfContents(frame()->document())); ExceptionCode ec = 0, ec2 = 0; if (!reset && !tickmarks_.isEmpty()) { // This is a continuation of a scoping operation that timed out and didn't // complete last time around, so we should start from where we left off. RefPtr start_range = tickmarks_.last(); searchRange->setStart(start_range->startContainer(), start_range->startOffset(ec2) + 1, ec); if (ec != 0 || ec2 != 0) { NOTREACHED(); return; } } // This timeout controls how long we scope (in ms) before releasing control. // This value does not prevent us from running for longer than this, but it // is periodically checked to see if we have exceeded our allocated time. static const int kTimeout = 100; // ms int matchCount = 0; bool timeout = false; Time start_time = Time::Now(); do { // Find next occurrence of the search string. // TODO(finnur): (http://b/1088245) This WebKit operation may run // for longer than the timeout value, and is not interruptible as it is // currently written. We may need to rewrite it with interruptibility in // mind, or find an alternative. RefPtr resultRange(findPlainText(searchRange.get(), webcore_string, true, request.match_case)); if (resultRange->collapsed(ec)) break; // no further matches. // A non-collapsed result range can in some funky whitespace cases still not // advance the range's start position (4509328). Break to avoid infinite // loop. (This function is based on the implementation of Frame::FindString, // which is where this safeguard comes from). VisiblePosition newStart = endVisiblePosition(resultRange.get(), WebCore::DOWNSTREAM); if (newStart == startVisiblePosition(searchRange.get(), WebCore::DOWNSTREAM)) break; ++matchCount; // Add the location we just found to the tickmarks collection. tickmarks_.append(resultRange); setStart(searchRange.get(), newStart); // Catch a special case where Find found something but doesn't know // what the bounding box for it is. In this case we set the first match // we find as the active rect. Note: This does not affect FindNext, it will // still do the right thing. This is only affecting the initial Find, so if // you start searching from the middle of the page AND there is a match // below AND we don't have a bounding box for that match, then we will mark // the first match as active. We probably should look into converting Find // to use the same function as the scoping effort (findPlainText), since it // seems to always get the right bounding box. IntRect result_bounds = resultRange->boundingBox(); if (locating_active_rect_ && active_selection_rect_.isEmpty()) { active_selection_rect_ = result_bounds; } // If the Find function found a match it will have stored where the // match was found in active_selection_rect_ on the current frame. If we // find this rect during scoping it means we have found the active // tickmark. if (locating_active_rect_ && (active_selection_rect_ == result_bounds)) { // We have found the active tickmark frame. main_frame_impl->active_tickmark_frame_ = this; // We also know which tickmark is active now. active_tickmark_ = tickmarks_.size() - 1; // To stop looking for the active tickmark, we set this flag. locating_active_rect_ = false; #if defined(OS_WIN) // TODO(pinkerton): Fix Mac invalidation to be more like Win ScrollView // Notify browser of new location for the selected rectangle. IntRect pos = tickmarks_[active_tickmark_]->boundingBox(); pos.move(-frameview()->scrollOffset().width(), -frameview()->scrollOffset().height()); ReportFindInPageSelection( gfx::Rect(frame()->view()->convertToContainingWindow(pos)), active_tickmark_ + 1, request.request_id); #endif } timeout = (Time::Now() - start_time).InMilliseconds() >= kTimeout; } while (!timeout); // Remember what we search for last time, so we can skip searching if more // letters are added to the search string (and last outcome was 0). last_search_string_ = request.search_string; if (matchCount > 0) { last_match_count_ += matchCount; // Let the mainframe know how much we found during this pass. main_frame_impl->IncreaseMatchCount(matchCount, request.request_id); } if (timeout) { // If we found anything during this pass, we should redraw. However, we // don't want to spam too much if the page is extremely long, so if we // reach a certain point we start throttling the redraw requests. if (matchCount > 0) InvalidateIfNecessary(); // Scoping effort ran out of time, lets ask for another time-slice. MessageLoop::current()->PostTask(FROM_HERE, scope_matches_factory_.NewRunnableMethod( &WebFrameImpl::ScopeStringMatches, request, false)); // don't reset. return; // Done for now, resume work later. } // This frame has no further scoping left, so it is done. Other frames might, // of course, continue to scope matches. scoping_complete_ = true; main_frame_impl->frames_scoping_count_--; // If this is the last frame to finish scoping we need to trigger the final // update to be sent. if (main_frame_impl->frames_scoping_count_ == 0) main_frame_impl->IncreaseMatchCount(0, request.request_id); // This frame is done, so show any tickmark/highlight we haven't drawn yet. InvalidateArea(INVALIDATE_ALL); return; } void WebFrameImpl::CancelPendingScopingEffort() { scope_matches_factory_.RevokeAll(); active_tickmark_ = WidgetClientWin::kNoTickmark; } void WebFrameImpl::SetFindEndstateFocusAndSelection() { WebFrameImpl* main_frame_impl = static_cast(GetView()->GetMainFrame()); if (this == main_frame_impl->active_tickmark_frame() && active_tickmark_ != WidgetClientWin::kNoTickmark) { RefPtr range = tickmarks_[active_tickmark_]; // Set the selection to what the active match is. frame()->selection()->setSelectedRange( range.get(), WebCore::DOWNSTREAM, false); // We will be setting focus ourselves, so we want the view to forget its // stored focus node so that it won't change it after we are done. static_cast(GetView())->ReleaseFocusReferences(); // Try to find the first focusable node up the chain, which will, for // example, focus links if we have found text within the link. Node* node = range->firstNode(); while (node && !node->isFocusable() && node != frame()->document()) node = node->parent(); if (node && node != frame()->document()) { // Found a focusable parent node. Set focus to it. frame()->document()->setFocusedNode(node); } else { // Iterate over all the nodes in the range until we find a focusable node. // This, for example, sets focus to the first link if you search for // text and text that is within one or more links. node = range->firstNode(); while (node && node != range->pastLastNode()) { if (node->isFocusable()) { frame()->document()->setFocusedNode(node); break; } node = node->traverseNextNode(); } } } } void WebFrameImpl::StopFinding(bool clear_selection) { if (!clear_selection) SetFindEndstateFocusAndSelection(); CancelPendingScopingEffort(); // Let the frame know that we don't want tickmarks or highlighting anymore. tickmarks_.clear(); InvalidateArea(INVALIDATE_ALL); } void WebFrameImpl::SelectAll() { frame()->selection()->selectAll(); WebViewDelegate* d = GetView()->GetDelegate(); if (d) d->UserMetricsRecordAction(L"SelectAll"); } void WebFrameImpl::Copy() { frame()->editor()->copy(); WebViewDelegate* d = GetView()->GetDelegate(); if (d) d->UserMetricsRecordAction(L"Copy"); } void WebFrameImpl::Cut() { frame()->editor()->cut(); WebViewDelegate* d = GetView()->GetDelegate(); if (d) d->UserMetricsRecordAction(L"Cut"); } #if defined(OS_WIN) // Returns a copy of data from a data handle retrieved from the clipboard. The // data is decoded according to the format that it is in. The caller is // responsible for freeing the data. static wchar_t* GetDataFromHandle(HGLOBAL data_handle, unsigned int clipboard_format) { switch (clipboard_format) { case CF_TEXT: { char* string_data = static_cast(::GlobalLock(data_handle)); int n_chars = ::MultiByteToWideChar(CP_ACP, 0, string_data, -1, NULL, 0); wchar_t* wcs_data = static_cast(malloc((n_chars * sizeof(wchar_t)) + sizeof(wchar_t))); if (!wcs_data) { ::GlobalUnlock(data_handle); return NULL; } ::MultiByteToWideChar(CP_ACP, 0, string_data, -1, wcs_data, n_chars); ::GlobalUnlock(data_handle); wcs_data[n_chars] = '\0'; return wcs_data; } case CF_UNICODETEXT: { wchar_t* string_data = static_cast(::GlobalLock(data_handle)); size_t data_size_in_bytes = ::GlobalSize(data_handle); wchar_t* wcs_data = static_cast(malloc(data_size_in_bytes + sizeof(wchar_t))); if (!wcs_data) { ::GlobalUnlock(data_handle); return NULL; } size_t n_chars = static_cast(data_size_in_bytes / sizeof(wchar_t)); wmemcpy_s(wcs_data, n_chars, string_data, n_chars); ::GlobalUnlock(data_handle); wcs_data[n_chars] = '\0'; return wcs_data; } } return NULL; } #endif void WebFrameImpl::Paste() { frame()->editor()->paste(); WebViewDelegate* d = GetView()->GetDelegate(); if (d) d->UserMetricsRecordAction(L"Paste"); } void WebFrameImpl::Replace(const std::wstring& wtext) { String text = webkit_glue::StdWStringToString(wtext); RefPtr fragment = createFragmentFromText(frame()->selection()->toRange().get(), text); WebCore::applyCommand(WebCore::ReplaceSelectionCommand::create( frame()->document(), fragment.get(), false, true, true)); } void WebFrameImpl::Delete() { frame()->editor()->command("Delete").execute(); WebViewDelegate* d = GetView()->GetDelegate(); if (d) d->UserMetricsRecordAction(L"DeleteSelection"); } void WebFrameImpl::Undo() { frame()->editor()->undo(); WebViewDelegate* d = GetView()->GetDelegate(); if (d) d->UserMetricsRecordAction(L"Undo"); } void WebFrameImpl::Redo() { frame()->editor()->redo(); WebViewDelegate* d = GetView()->GetDelegate(); if (d) d->UserMetricsRecordAction(L"Redo"); } void WebFrameImpl::ClearSelection() { frame()->selection()->clear(); } void WebFrameImpl::CreateFrameView() { ASSERT(frame_); // If frame_ doesn't exist, we probably didn't init properly. WebCore::Page* page = frame_->page(); DCHECK(page); DCHECK(page->mainFrame() != NULL); #if defined(OS_WIN) // TODO(pinkerton): figure out view show/hide like win // Detach the current view. This ensures that UI widgets like plugins, // etc are detached(hidden) if (frame_->view()) frame_->view()->detachFromWindow(); #endif frame_->setView(0); WebCore::FrameView* view = new FrameView(frame_.get()); frame_->setView(view); #if defined(OS_WIN) // Attaching the view ensures that UI widgets like plugins, display/hide // correctly. frame_->view()->attachToWindow(); #endif if (margin_width_ >= 0) view->setMarginWidth(margin_width_); if (margin_height_ >= 0) view->setMarginHeight(margin_height_); if (!allows_scrolling_) view->setScrollbarsMode(WebCore::ScrollbarAlwaysOff); // TODO(darin): The Mac code has a comment about this possibly being // unnecessary. See installInFrame in WebCoreFrameBridge.mm if (frame_->ownerRenderer()) frame_->ownerRenderer()->setWidget(view); view->initScrollbars(); // FrameViews are created with a refcount of 1 so it needs releasing after we // assign it to a RefPtr. view->deref(); WebFrameImpl* parent = static_cast(GetParent()); if (parent) { parent->frameview()->addChild(view); } else { view->setClient(webview_impl_); IntRect geom(0, 0, webview_impl_->size().width(), webview_impl_->size().height()); view->setFrameGeometry(geom); } } // static WebFrameImpl* WebFrameImpl::FromFrame(WebCore::Frame* frame) { return static_cast( frame->loader()->client())->webframe(); } // WebFrame -------------------------------------------------------------------- void WebFrameImpl::Layout() { // layout this frame FrameView* view = frame_->view(); if (view) view->layout(); // recursively layout child frames Frame* child = frame_->tree()->firstChild(); for (; child; child = child->tree()->nextSibling()) FromFrame(child)->Layout(); } void WebFrameImpl::Paint(gfx::PlatformCanvas* canvas, const gfx::Rect& rect) { static StatsRate rendering(L"WebFramePaintTime"); StatsScope rendering_scope(rendering); if (!rect.IsEmpty()) { IntRect dirty_rect(rect.x(), rect.y(), rect.width(), rect.height()); #if defined(OS_MACOSX) CGContextRef context = canvas->getTopPlatformDevice().GetBitmapContext(); GraphicsContext gc(context); #else PlatformContextSkia context(canvas); // PlatformGraphicsContext is actually a pointer to PlatformContextSkia GraphicsContext gc(reinterpret_cast(&context)); #endif if (frame_->document() && frameview()) { frameview()->paint(&gc, dirty_rect); } else { gc.fillRect(dirty_rect, Color::white); } } } #if defined(OS_WIN) gfx::BitmapPlatformDevice WebFrameImpl::CaptureImage(bool scroll_to_zero) { // Must layout before painting. Layout(); gfx::PlatformCanvasWin canvas(frameview()->width(), frameview()->height(), true); PlatformContextSkia context(&canvas); GraphicsContext gc(reinterpret_cast(&context)); frameview()->paint(&gc, IntRect(0, 0, frameview()->width(), frameview()->height())); gfx::BitmapPlatformDeviceWin& device = static_cast(canvas.getTopPlatformDevice()); device.fixupAlphaBeforeCompositing(); return device; } #elif defined(OS_MACOSX) gfx::BitmapPlatformDevice WebFrameImpl::CaptureImage(bool scroll_to_zero) { // Must layout before painting. Layout(); gfx::PlatformCanvasMac canvas(frameview()->width(), frameview()->height(), true); CGContextRef context = canvas.beginPlatformPaint(); GraphicsContext gc(context); frameview()->paint(&gc, IntRect(0, 0, frameview()->width(), frameview()->height())); canvas.endPlatformPaint(); gfx::BitmapPlatformDevice& device = static_cast(canvas.getTopPlatformDevice()); return device; } #else gfx::BitmapPlatformDevice WebFrameImpl::CaptureImage(bool scroll_to_zero) { NOTIMPLEMENTED(); } #endif bool WebFrameImpl::IsLoading() { // I'm assuming this does what we want. return frame_->loader()->isLoading(); } void WebFrameImpl::Closing() { // let go of our references, this breaks reference cycles and will // usually eventually lead to us being destroyed. if (frameview()) frameview()->clear(); if (frame_) { StopLoading(); frame_ = NULL; } alt_error_page_fetcher_.reset(); webview_impl_ = NULL; } void WebFrameImpl::DidReceiveData(DocumentLoader* loader, const char* data, int length) { // Set the text encoding. This calls begin() for us. It is safe to call // this multiple times (Mac does: page/mac/WebCoreFrameBridge.mm). bool user_chosen = true; String encoding = frame_->loader()->documentLoader()->overrideEncoding(); if (encoding.isNull()) { user_chosen = false; encoding = loader->response().textEncodingName(); } frame_->loader()->setEncoding(encoding, user_chosen); // NOTE: mac only does this if there is a document frame_->loader()->addData(data, length); // It's possible that we get a DNS failure followed by a second load that // succeeds before we hear back from the alternate error page server. In // that case, cancel the alt error page download. alt_error_page_fetcher_.reset(); } void WebFrameImpl::DidFail(const ResourceError& error, bool was_provisional) { // Make sure we never show errors in view source mode. SetInViewSourceMode(false); WebViewDelegate* delegate = webview_impl_->delegate(); if (delegate) { WebErrorImpl web_error(error); if (was_provisional) { delegate->DidFailProvisionalLoadWithError(webview_impl_, web_error, this); } else { delegate->DidFailLoadWithError(webview_impl_, web_error, this); } } } void WebFrameImpl::LoadAlternateHTMLErrorPage(const WebRequest* request, const WebError& error, const GURL& error_page_url, bool replace, const GURL& fake_url) { // Load alternate HTML in place of the previous request. We create a copy of // the original request so we can replace its URL with a dummy URL. That // prevents other web content from the same origin as the failed URL to // script the error page. scoped_ptr failed_request(request->Clone()); failed_request->SetURL(fake_url); LoadAlternateHTMLString(failed_request.get(), std::string(), error.GetFailedURL(), replace); WebErrorImpl weberror_impl(error); alt_error_page_fetcher_.reset( new AltErrorPageResourceFetcher(webview_impl_, weberror_impl, this, error_page_url)); } std::wstring WebFrameImpl::GetName() { return webkit_glue::StringToStdWString(frame_->tree()->name()); } WebTextInput* WebFrameImpl::GetTextInput() { if (!webtextinput_impl_.get()) { webtextinput_impl_.reset(new WebTextInputImpl(this)); } return webtextinput_impl_.get(); } void WebFrameImpl::SetPrinting(bool printing, float page_width_min, float page_width_max) { frame_->setPrinting(printing, page_width_min, page_width_max, true); } bool WebFrameImpl::Visible() { return frame()->view()->visibleWidth() > 0 && frame()->view()->visibleHeight() > 0; } void WebFrameImpl::CreateChildFrame(const FrameLoadRequest& r, HTMLFrameOwnerElement* owner_element, bool allows_scrolling, int margin_height, int margin_width, Frame*& result) { // TODO(darin): share code with initWithName() scoped_refptr webframe = new WebFrameImpl(); // Add an extra ref on behalf of the Frame/FrameLoader, which references the // WebFrame via the FrameLoaderClient interface. See the comment at the top // of this file for more info. webframe->AddRef(); webframe->allows_scrolling_ = allows_scrolling; webframe->margin_width_ = margin_width; webframe->margin_height_ = margin_height; webframe->frame_ = Frame::create(frame_->page(), owner_element, &webframe->frame_loader_client_); webframe->frame_->tree()->setName(r.frameName()); webframe->webview_impl_ = webview_impl_; // owning ref // We wait until loader()->load() returns before deref-ing the Frame. // Otherwise the danger is that the onload handler can cause // the Frame to be dealloc-ed, and subsequently trash memory. // (b:1055700) WTF::RefPtr protector(webframe->frame_.get()); frame_->tree()->appendChild(webframe->frame_); // Frame::init() can trigger onload event in the parent frame, // which may detach this frame and trigger a null-pointer access // in FrameTree::removeChild. Move init() after appendChild call // so that webframe->frame_ is in the tree before triggering // onload event handler. // Because the event handler may set webframe->frame_ to null, // it is necessary to check the value after calling init() and // return without loading URL. // (b:791612) webframe->frame_->init(); // create an empty document if (!webframe->frame_.get()) return; // The following code was pulled from WebFrame.mm:_loadURL, with minor // modifications. The purpose is to ensure we load the right HistoryItem for // this child frame. HistoryItem* parentItem = frame_->loader()->currentHistoryItem(); FrameLoadType loadType = frame_->loader()->loadType(); FrameLoadType childLoadType = WebCore::FrameLoadTypeRedirectWithLockedHistory; KURL new_url = r.resourceRequest().url(); // If we're moving in the backforward list, we might want to replace the // content of this child frame with whatever was there at that point. // Reload will maintain the frame contents, LoadSame will not. if (parentItem && parentItem->children().size() != 0 && (isBackForwardLoadType(loadType) || loadType == WebCore::FrameLoadTypeReload || loadType == WebCore::FrameLoadTypeReloadAllowingStaleData)) { HistoryItem* childItem = parentItem->childItemWithName(r.frameName()); if (childItem) { // Use the original URL to ensure we get all the side-effects, such as // onLoad handlers, of any redirects that happened. An example of where // this is needed is Radar 3213556. new_url = KURL(KURL(""), childItem->originalURLString()); // These behaviors implied by these loadTypes should apply to the child // frames childLoadType = loadType; if (isBackForwardLoadType(loadType)) { // For back/forward, remember this item so we can traverse any child // items as child frames load. webframe->frame_->loader()->setProvisionalHistoryItem(childItem); } else { // For reload, just reinstall the current item, since a new child frame // was created but we won't be creating a new BF item webframe->frame_->loader()->setCurrentHistoryItem(childItem); } } } webframe->frame_->loader()->loadURLIntoChildFrame(new_url, r.resourceRequest().httpReferrer(), webframe->frame_.get()); // A synchronous navigation (about:blank) would have already processed // onload, so it is possible for the frame to have already been destroyed by // script in the page. result = webframe->frame_.get(); } bool WebFrameImpl::ExecuteCoreCommandByName(const std::string& name, const std::string& value) { ASSERT(frame()); return frame()->editor()->command(webkit_glue::StdStringToString(name)) .execute(webkit_glue::StdStringToString(value)); } void WebFrameImpl::AddMessageToConsole(const std::wstring& msg, ConsoleMessageLevel level) { ASSERT(frame()); WebCore::MessageLevel webcore_message_level; switch (level) { case MESSAGE_LEVEL_TIP: webcore_message_level = WebCore::TipMessageLevel; break; case MESSAGE_LEVEL_LOG: webcore_message_level = WebCore::LogMessageLevel; break; case MESSAGE_LEVEL_WARNING: webcore_message_level = WebCore::WarningMessageLevel; break; case MESSAGE_LEVEL_ERROR: webcore_message_level = WebCore::ErrorMessageLevel; break; default: NOTREACHED(); return; } frame()->domWindow()->console()->addMessage( WebCore::OtherMessageSource, webcore_message_level, webkit_glue::StdWStringToString(msg), 1, String()); } void WebFrameImpl::ClosePage() { // TODO(creis): Find a way to use WebView::Close() instead. (See comments in // webframe.h and RenderView::OnClosePage.) frame_->loader()->closeURL(); } gfx::Size WebFrameImpl::ScrollOffset() const { WebCore::FrameView* view = frameview(); if (view) { WebCore::IntSize s = view->scrollOffset(); return gfx::Size(s.width(), s.height()); } return gfx::Size(); } void WebFrameImpl::SetAllowsScrolling(bool flag) { allows_scrolling_ = flag; #if defined(OS_WIN) // TODO(pinkerton): fix when we figure out scrolling apis frame_->view()->setAllowsScrolling(flag); #endif } bool WebFrameImpl::SetPrintingMode(bool printing, float page_width_min, float page_width_max, int* width) { // Make sure main frame is loaded. WebCore::FrameView* view = frameview(); if (!view) { NOTREACHED(); return false; } printing_ = printing; if (printing) { view->setScrollbarsMode(WebCore::ScrollbarAlwaysOff); } else { view->setScrollbarsMode(WebCore::ScrollbarAuto); } DCHECK_EQ(frame()->isFrameSet(), false); SetPrinting(printing, page_width_min, page_width_max); if (!printing) pages_.clear(); // The document width is well hidden. if (width) *width = frame()->document()->renderer()->width(); return true; } int WebFrameImpl::ComputePageRects(const gfx::Size& page_size_px) { if (!printing_ || !frame() || !frame()->document()) { NOTREACHED(); return 0; } // In Safari, they are using: // (0,0) + soft margins top/left // (phys width, phys height) - hard margins - // soft margins top/left - soft margins right/bottom // TODO(maruel): Weird. We don't do that. // Everything is in pixels :( // pages_ and page_height are actually output parameters. int page_height; WebCore::IntRect rect(0, 0, page_size_px.width(), page_size_px.height()); computePageRectsForFrame(frame(), rect, 0, 0, 1.0, pages_, page_height); return pages_.size(); } void WebFrameImpl::GetPageRect(int page, gfx::Rect* page_size) const { if (page < 0 || page >= static_cast(pages_.size())) { NOTREACHED(); return; } *page_size = pages_[page]; } bool WebFrameImpl::SpoolPage(int page, PlatformContextSkia* context) { // Ensure correct state. if (!context || !printing_ || page < 0 || page >= static_cast(pages_.size())) { NOTREACHED(); return false; } if (!frame() || !frame()->document()) { NOTREACHED(); return false; } GraphicsContext spool(reinterpret_cast(context)); DCHECK(pages_[page].x() == 0); // Offset to get the right square. spool.translate(0, -static_cast(pages_[page].y())); frame()->paint(&spool, pages_[page]); return true; } bool WebFrameImpl::HasUnloadListener() { if (frame() && frame()->document()) { Document* doc = frame()->document(); return doc->hasUnloadEventListener(); } return false; } bool WebFrameImpl::IsReloadAllowingStaleData() const { FrameLoader* loader = frame() ? frame()->loader() : NULL; if (loader) { return WebCore::FrameLoadTypeReloadAllowingStaleData == loader->policyLoadType(); } return false; } int WebFrameImpl::PendingFrameUnloadEventCount() const { return frame()->eventHandler()->pendingFrameUnloadEventCount(); }