Stop serializing WebString over IPC. The new rule is that only POD (plain ol...

webkit/glue/webframe_impl.cc

 /*
  * 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
@@ skipping 118 matching lines @@
 #include "base/basictypes.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 "net/base/net_errors.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebConsoleMessage.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFindInPageRequest.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebFindOptions.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebScriptSource.h"
 #include "webkit/glue/alt_error_page_resource_fetcher.h"
 #include "webkit/glue/dom_operations.h"
 #include "webkit/glue/dom_operations_private.h"
 #include "webkit/glue/feed.h"
 #include "webkit/glue/glue_serialize.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webdatasource_impl.h"
 #include "webkit/glue/weberror_impl.h"
 #include "webkit/glue/webframe_impl.h"
 #include "webkit/glue/webhistoryitem_impl.h"
 #include "webkit/glue/weburlrequest_impl.h"
 #include "webkit/glue/webtextinput_impl.h"
 #include "webkit/glue/webview_impl.h"
 
 #if defined(OS_LINUX)
 #include <gdk/gdk.h>
 #endif
 
 #if USE(JSC)
 #include "bridge/c/c_instance.h"
 #include "bridge/runtime_object.h"
 #endif
 
 using base::Time;
+
 using WebCore::ChromeClientChromium;
 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;
@@ skipping 12 matching lines @@
 using WebCore::ResourceError;
 using WebCore::ResourceHandle;
 using WebCore::ResourceRequest;
 using WebCore::VisibleSelection;
 using WebCore::SharedBuffer;
 using WebCore::String;
 using WebCore::SubstituteData;
 using WebCore::TextIterator;
 using WebCore::VisiblePosition;
 using WebCore::XPathResult;
+
 using WebKit::WebConsoleMessage;
-using WebKit::WebFindInPageRequest;
+using WebKit::WebFindOptions;
 using WebKit::WebScriptSource;
 
 // Key for a StatsCounter tracking how many WebFrames are active.
 static const char* const kWebFrameActiveCount = "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";
@@ skipping 731 matching lines @@
         OrdinalOfFirstMatchForFrame(this) + active_match_ordinal,
         selection_rect);
   }
 }
 
 void WebFrameImpl::ResetMatchCount() {
   total_matchcount_ = 0;
   frames_scoping_count_ = 0;
 }
 
-bool WebFrameImpl::Find(const WebFindInPageRequest& request,
+bool WebFrameImpl::Find(int request_id,
+                        const string16& search_text,
+                        const WebFindOptions& options,
                         bool wrap_within_frame,
                         gfx::Rect* selection_rect) {
-  WebCore::String webcore_string =
-      webkit_glue::WebStringToString(request.text);
+  WebCore::String webcore_string = webkit_glue::String16ToString(search_text);
 
   WebFrameImpl* const main_frame_impl =
       static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
 
-  if (!request.findNext)
+  if (!options.findNext)
     frame()->page()->unmarkAllTextMatches();
 
   // Starts the search from the current selection.
   bool start_in_selection = true;
 
   DCHECK(frame() && frame()->view());
-  bool found = frame()->findString(webcore_string, request.forward,
-                                   request.matchCase, wrap_within_frame,
+  bool found = frame()->findString(webcore_string, options.forward,
+                                   options.matchCase, wrap_within_frame,
                                    start_in_selection);
   if (found) {
 #if defined(OS_WIN)
     WebCore::RenderThemeChromiumWin::setFindInPageMode(true);
 #endif
     // Store which frame was active. This will come in handy later when we
     // change the active match ordinal below.
     WebFrameImpl* old_active_frame = main_frame_impl->active_match_frame_;
     // Set this frame as the active frame (the one with the active highlight).
     main_frame_impl->active_match_frame_ = this;
 
     // We found something, so we can now query the selection for its position.
     VisibleSelection new_selection(frame()->selection()->selection());
     IntRect curr_selection_rect;
 
     // 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())) {
       active_match_ = NULL;
     } else {
       active_match_ = new_selection.toNormalizedRange();
       curr_selection_rect = active_match_->boundingBox();
     }
 
-    if (!request.findNext) {
+    if (!options.findNext) {
       // This is a Find operation, so we set the flag to ask the scoping effort
       // to find the active rect for us so we can update the ordinal (n of m).
       locating_active_rect_ = true;
     } else {
       if (old_active_frame != this) {
         // If the active frame has changed it means that we have a multi-frame
         // page and we just switch to searching in a new frame. Then we just
         // want to reset the index.
-        if (request.forward)
+        if (options.forward)
           active_match_index_ = 0;
         else
           active_match_index_ = last_match_count_ - 1;
       } else {
         // We are still the active frame, so increment (or decrement) the
         // |active_match_index|, wrapping if needed (on single frame pages).
-        request.forward ? ++active_match_index_ : --active_match_index_;
+        options.forward ? ++active_match_index_ : --active_match_index_;
         if (active_match_index_ + 1 > last_match_count_)
           active_match_index_ = 0;
         if (active_match_index_ + 1 == 0)
           active_match_index_ = last_match_count_ - 1;
       }
 #if defined(OS_WIN)
       // TODO(pinkerton): Fix Mac scrolling to be more like Win ScrollView
       if (selection_rect) {
         gfx::Rect rect = webkit_glue::FromIntRect(
             frame()->view()->convertToContainingWindow(curr_selection_rect));
         rect.Offset(-frameview()->scrollOffset().width(),
                     -frameview()->scrollOffset().height());
         *selection_rect = rect;
 
         ReportFindInPageSelection(rect,
                                   active_match_index_ + 1,
-                                  request.identifier);
+                                  request_id);
       }
 #endif
     }
   } else {
     // Nothing was found in this frame.
     active_match_ = NULL;
 
     // Erase all previous tickmarks and highlighting.
     InvalidateArea(INVALIDATE_ALL);
   }
@@ skipping 11 matching lines @@
        it != frame;
        it = static_cast<WebFrameImpl*>(
            webview_impl_->GetNextFrameAfter(it, true))) {
     if (it->last_match_count_ > 0)
       ordinal += it->last_match_count_;
   }
 
   return ordinal;
 }
 
-bool WebFrameImpl::ShouldScopeMatches(const WebFindInPageRequest& request) {
+bool WebFrameImpl::ShouldScopeMatches(const string16& search_text) {
   // 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_.empty() && last_match_count_ == 0) {
     // Check to see if the search string prefixes match.
     string16 previous_search_prefix =
-        string16(request.text).substr(0, last_search_string_.length());
+        search_text.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() {
@@ skipping 40 matching lines @@
       Vector<WebCore::DocumentMarker> markers =
           frame()->document()->markersForNode(node);
       frame()->document()->setRenderedRectForMarker(
           textPiece->startContainer(exception),
           markers[markers.size() - 1],
           range->boundingBox());
     }
   }
 }
 
-void WebFrameImpl::ScopeStringMatches(const WebFindInPageRequest& request,
+void WebFrameImpl::ScopeStringMatches(int request_id,
+                                      const string16& search_text,
+                                      const WebFindOptions& options,
                                       bool reset) {
-  if (!ShouldScopeMatches(request))
+  if (!ShouldScopeMatches(search_text))
     return;
 
   WebFrameImpl* main_frame_impl =
       static_cast<WebFrameImpl*>(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;
     // Clear highlighting for this frame.
     if (frame()->markedTextMatchesAreHighlighted())
       frame()->page()->unmarkAllTextMatches();
     // Clear the counters from last operation.
     last_match_count_ = 0;
     next_invalidate_after_ = 0;
 
     resume_scoping_from_range_ = NULL;
 
     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,
+            request_id,
+            search_text,
+            options,
             false));  // false=we just reset, so don't do it again.
     return;
   }
 
-  WebCore::String webcore_string =
-      webkit_glue::WebStringToString(request.text);
+  WebCore::String webcore_string = webkit_glue::String16ToString(search_text);
 
   RefPtr<Range> search_range(rangeOfContents(frame()->document()));
 
   ExceptionCode ec = 0, ec2 = 0;
   if (resume_scoping_from_range_.get()) {
     // 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.
     search_range->setStart(resume_scoping_from_range_->startContainer(),
                            resume_scoping_from_range_->startOffset(ec2) + 1,
                            ec);
@@ skipping 14 matching lines @@
   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<Range> result_range(findPlainText(search_range.get(),
                                             webcore_string,
                                             true,
-                                            request.matchCase));
+                                            options.matchCase));
     if (result_range->collapsed(ec)) {
       if (!result_range->startContainer()->isInShadowTree())
         break;
 
       search_range = rangeOfContents(frame()->document());
       search_range->setStartAfter(
           result_range->startContainer()->shadowAncestorNode(), ec);
       continue;
     }
 
@@ skipping 34 matching lines @@
       // 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_match_frame_ = this;
         // We also know which tickmark is active now.
         active_match_index_ = match_count - 1;
         // To stop looking for the active tickmark, we set this flag.
         locating_active_rect_ = false;
 
-  #if defined(OS_WIN)
+#if defined(OS_WIN)
         // TODO(pinkerton): Fix Mac invalidation to be more like Win ScrollView
         // Notify browser of new location for the selected rectangle.
         result_bounds.move(-frameview()->scrollOffset().width(),
                            -frameview()->scrollOffset().height());
         ReportFindInPageSelection(
             webkit_glue::FromIntRect(
                 frame()->view()->convertToContainingWindow(result_bounds)),
                 active_match_index_ + 1,
-                request.identifier);
-  #endif
+                request_id);
+#endif
       }
     }
 
     resume_scoping_from_range_ = result_range;
     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.text;
+  last_search_string_ = search_text;
 
   if (match_count > 0) {
     frame()->setMarkedTextMatchesAreHighlighted(true);
 
     last_match_count_ += match_count;
 
     // Let the mainframe know how much we found during this pass.
-    main_frame_impl->IncreaseMatchCount(match_count, request.identifier);
+    main_frame_impl->IncreaseMatchCount(match_count, 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 (match_count > 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,
+            request_id,
+            search_text,
+            options,
             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.identifier);
+    main_frame_impl->IncreaseMatchCount(0, request_id);
 
   // This frame is done, so show any scrollbar tickmarks we haven't drawn yet.
   InvalidateArea(INVALIDATE_SCROLLBAR);
-
-  return;
 }
 
 void WebFrameImpl::CancelPendingScopingEffort() {
   scope_matches_factory_.RevokeAll();
   active_match_index_ = -1;
 }
 
 void WebFrameImpl::SetFindEndstateFocusAndSelection() {
   WebFrameImpl* main_frame_impl =
       static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
@@ skipping 601 matching lines @@
   return password_listeners_.get(input_element);
 }
 
 void WebFrameImpl::ClearPasswordListeners() {
   for (PasswordListenerMap::iterator iter = password_listeners_.begin();
        iter != password_listeners_.end(); ++iter) {
     delete iter->second;
   }
   password_listeners_.clear();
 }