Replace MessageLoop+ScopedRunnableMethodFactory with WebCore::Timer+Vector...

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 110 matching lines @@
 #include "SelectionController.h"
 #include "Settings.h"
 #include "SkiaUtils.h"
 #include "SubstituteData.h"
 #include "TextIterator.h"
 #include "TextAffinity.h"
 #include "XPathResult.h"
 #include <wtf/CurrentTime.h>
 #undef LOG
 
-#include "base/message_loop.h"
 #include "webkit/api/public/WebConsoleMessage.h"
 #include "webkit/api/public/WebFindOptions.h"
 #include "webkit/api/public/WebForm.h"
 #include "webkit/api/public/WebFrameClient.h"
 #include "webkit/api/public/WebHistoryItem.h"
 #include "webkit/api/public/WebRange.h"
 #include "webkit/api/public/WebRect.h"
 #include "webkit/api/public/WebScriptSource.h"
 #include "webkit/api/public/WebSecurityOrigin.h"
 #include "webkit/api/public/WebSize.h"
@@ skipping 40 matching lines @@
 using WebCore::ResourceHandle;
 using WebCore::ResourceRequest;
 using WebCore::ResourceResponse;
 using WebCore::VisibleSelection;
 using WebCore::ScriptValue;
 using WebCore::SecurityOrigin;
 using WebCore::SharedBuffer;
 using WebCore::String;
 using WebCore::SubstituteData;
 using WebCore::TextIterator;
+using WebCore::Timer;
 using WebCore::VisiblePosition;
 using WebCore::XPathResult;
 
 using WebKit::PasswordAutocompleteListener;
 using WebKit::WebCanvas;
 using WebKit::WebConsoleMessage;
 using WebKit::WebData;
 using WebKit::WebDataSource;
 using WebKit::WebDataSourceImpl;
 using WebKit::WebFindOptions;
@@ skipping 139 matching lines @@
   float printed_page_width_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromePrintContext);
 };
 
 static WebDataSource* DataSourceForDocLoader(DocumentLoader* loader) {
   return loader ? WebDataSourceImpl::fromDocumentLoader(loader) : NULL;
 }
 
+
+// WebFrame -------------------------------------------------------------------
+
+class WebFrameImpl::DeferredScopeStringMatches {
+ public:
+  DeferredScopeStringMatches(WebFrameImpl* webframe,
+                             int identifier,
+                             const WebString& search_text,
+                             const WebFindOptions& options,
+                             bool reset)
+      : timer_(this, &DeferredScopeStringMatches::DoTimeout),
+        webframe_(webframe),
+        identifier_(identifier),
+        search_text_(search_text),
+        options_(options),
+        reset_(reset) {
+    timer_.startOneShot(0.0);
+  }
+
+ private:
+  void DoTimeout(Timer<DeferredScopeStringMatches>*) {
+    webframe_->CallScopeStringMatches(
+        this, identifier_, search_text_, options_, reset_);
+  }
+
+  Timer<DeferredScopeStringMatches> timer_;
+  RefPtr<WebFrameImpl> webframe_;
+  int identifier_;
+  WebString search_text_;
+  WebFindOptions options_;
+  bool reset_;
+};
+
+
 // WebFrame -------------------------------------------------------------------
 
 // static
 WebFrame* WebFrame::frameForEnteredContext() {
   Frame* frame =
       WebCore::ScriptController::retrieveFrameForEnteredContext();
   return WebFrameImpl::FromFrame(frame);
 }
 
 // static
@@ skipping 859 matching lines @@
       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.
-    // TODO(darin): Replace with a WebCore Timer.
-    MessageLoop::current()->PostTask(FROM_HERE,
-        scope_matches_factory_.NewRunnableMethod(
-            &WebFrameImpl::scopeStringMatches,
-            request_id,
-            search_text,
-            options,
-            false));  // false=we just reset, so don't do it again.
+    ScopeStringMatchesSoon(
+        request_id,
+        search_text,
+        options,
+        false);  // false=we just reset, so don't do it again.
     return;
   }
 
   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
@@ skipping 111 matching lines @@
   }
 
   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.
-    // TODO(darin): Replace with a WebCore Timer.
-    MessageLoop::current()->PostTask(FROM_HERE,
-        scope_matches_factory_.NewRunnableMethod(
-            &WebFrameImpl::scopeStringMatches,
-            request_id,
-            search_text,
-            options,
-            false));  // don't reset.
-
+    ScopeStringMatchesSoon(
+        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_id);
 
   // This frame is done, so show any scrollbar tickmarks we haven't drawn yet.
   InvalidateArea(INVALIDATE_SCROLLBAR);
 }
 
 void WebFrameImpl::cancelPendingScopingEffort() {
-  scope_matches_factory_.RevokeAll();
+  deleteAllValues(deferred_scoping_work_);
+  deferred_scoping_work_.clear();
+
   active_match_index_ = -1;
 }
 
 void WebFrameImpl::increaseMatchCount(int count, int request_id) {
   // This function should only be called on the mainframe.
   ASSERT(!parent());
 
   total_matchcount_ += count;
 
   // Update the UI with the latest findings.
@@ skipping 43 matching lines @@
 // WebFrameImpl public ---------------------------------------------------------
 
 int WebFrameImpl::live_object_count_ = 0;
 
 PassRefPtr<WebFrameImpl> WebFrameImpl::create(WebFrameClient* client) {
   return adoptRef(new WebFrameImpl(ClientHandle::create(client)));
 }
 
 WebFrameImpl::WebFrameImpl(PassRefPtr<ClientHandle> client_handle)
   : ALLOW_THIS_IN_INITIALIZER_LIST(frame_loader_client_(this)),
-    ALLOW_THIS_IN_INITIALIZER_LIST(scope_matches_factory_(this)),
     client_handle_(client_handle),
     active_match_frame_(NULL),
     active_match_index_(-1),
     locating_active_rect_(false),
     resume_scoping_from_range_(NULL),
     last_match_count_(-1),
     total_matchcount_(-1),
     frames_scoping_count_(-1),
     scoping_complete_(false),
     next_invalidate_after_(0) {
@@ skipping 345 matching lines @@
         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::ScopeStringMatchesSoon(
+    int identifier, const WebString& search_text,
+    const WebFindOptions& options, bool reset) {
+  deferred_scoping_work_.append(new DeferredScopeStringMatches(
+      this, identifier, search_text, options, reset));
+}
+
+void WebFrameImpl::CallScopeStringMatches(
+    DeferredScopeStringMatches* caller, int identifier,
+    const WebString& search_text, const WebFindOptions& options, bool reset) {
+  deferred_scoping_work_.remove(deferred_scoping_work_.find(caller));
+
+  scopeStringMatches(identifier, search_text, options, reset);
+
+  // This needs to happen last since search_text is passed by reference.
+  delete caller;
+}
+
 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;
@@ skipping 34 matching lines @@
 
   SecurityOrigin* security_origin = frame_->document()->securityOrigin();
 
   if (!frame_->redirectScheduler()->locationChangePending()) {
     frame_->loader()->stopAllLoaders();
     frame_->loader()->begin(frame_->loader()->url(), true, security_origin);
     frame_->loader()->write(script_result);
     frame_->loader()->end();
   }
 }