Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/common/extensions/extension_messages.h"
      6 #include "chrome/renderer/extensions/chrome_v8_context.h"
      7 #include "chrome/renderer/extensions/chrome_v8_extension.h"
      8 #include "chrome/renderer/extensions/content_watcher.h"
      9 #include "chrome/renderer/extensions/dispatcher.h"
     10 #include "content/public/renderer/render_view.h"
     11 #include "content/public/renderer/render_view_visitor.h"
     12 #include "third_party/WebKit/public/web/WebDocument.h"
     13 #include "third_party/WebKit/public/web/WebFrame.h"
     14 #include "third_party/WebKit/public/web/WebView.h"
     15 
     16 namespace extensions {
     17 
     18 namespace {
     19 
     20 class MutationHandler : public ChromeV8Extension {
     21  public:
     22   explicit MutationHandler(Dispatcher* dispatcher,
     23                            ChromeV8Context* context,
     24                            base::WeakPtr<ContentWatcher> content_watcher)
     25       : ChromeV8Extension(dispatcher, context),
     26         content_watcher_(content_watcher) {
     27     RouteFunction("FrameMutated",
     28                   base::Bind(&MutationHandler::FrameMutated,
     29                              base::Unretained(this)));
     30   }
     31 
     32  private:
     33   void FrameMutated(const v8::FunctionCallbackInfo<v8::Value>& args) {
     34     if (content_watcher_.get()) {
     35       content_watcher_->ScanAndNotify(
     36           WebKit::WebFrame::frameForContext(context()->v8_context()));
     37     }
     38   }
     39 
     40   base::WeakPtr<ContentWatcher> content_watcher_;
     41 };
     42 
     43 }  // namespace
     44 
     45 ContentWatcher::ContentWatcher(Dispatcher* dispatcher)
     46     : weak_ptr_factory_(this),
     47       dispatcher_(dispatcher) {}
     48 ContentWatcher::~ContentWatcher() {}
     49 
     50 scoped_ptr<NativeHandler> ContentWatcher::MakeNatives(
     51     ChromeV8Context* context) {
     52   return scoped_ptr<NativeHandler>(new MutationHandler(
     53       dispatcher_, context, weak_ptr_factory_.GetWeakPtr()));
     54 }
     55 
     56 void ContentWatcher::OnWatchPages(
     57     const std::vector<std::string>& new_css_selectors) {
     58   if (new_css_selectors == css_selectors_)
     59     return;
     60 
     61   css_selectors_ = new_css_selectors;
     62 
     63   for (std::map<WebKit::WebFrame*,
     64                 std::vector<base::StringPiece> >::iterator
     65            it = matching_selectors_.begin();
     66        it != matching_selectors_.end(); ++it) {
     67     WebKit::WebFrame* frame = it->first;
     68     if (!css_selectors_.empty())
     69       EnsureWatchingMutations(frame);
     70 
     71     // Make sure to replace the contents of it->second because it contains
     72     // dangling StringPieces that referred into the old css_selectors_ content.
     73     it->second = FindMatchingSelectors(frame);
     74   }
     75 
     76   // For each top-level frame, inform the browser about its new matching set of
     77   // selectors.
     78   struct NotifyVisitor : public content::RenderViewVisitor {
     79     explicit NotifyVisitor(ContentWatcher* watcher) : watcher_(watcher) {}
     80     virtual bool Visit(content::RenderView* view) OVERRIDE {
     81       watcher_->NotifyBrowserOfChange(view->GetWebView()->mainFrame());
     82       return true;  // Continue visiting.
     83     }
     84     ContentWatcher* watcher_;
     85   };
     86   NotifyVisitor visitor(this);
     87   content::RenderView::ForEach(&visitor);
     88 }
     89 
     90 void ContentWatcher::DidCreateDocumentElement(WebKit::WebFrame* frame) {
     91   // Make sure the frame is represented in the matching_selectors_ map.
     92   matching_selectors_[frame];
     93 
     94   if (!css_selectors_.empty()) {
     95     EnsureWatchingMutations(frame);
     96   }
     97 }
     98 
     99 void ContentWatcher::EnsureWatchingMutations(WebKit::WebFrame* frame) {
    100   v8::HandleScope scope;
    101   v8::Context::Scope context_scope(frame->mainWorldScriptContext());
    102   if (ModuleSystem* module_system = GetModuleSystem(frame)) {
    103     ModuleSystem::NativesEnabledScope scope(module_system);
    104     module_system->Require("contentWatcher");
    105   }
    106 }
    107 
    108 ModuleSystem* ContentWatcher::GetModuleSystem(WebKit::WebFrame* frame) const {
    109   ChromeV8Context* v8_context =
    110       dispatcher_->v8_context_set().GetByV8Context(
    111           frame->mainWorldScriptContext());
    112 
    113   if (!v8_context)
    114     return NULL;
    115   return v8_context->module_system();
    116 }
    117 
    118 void ContentWatcher::ScanAndNotify(WebKit::WebFrame* frame) {
    119   std::vector<base::StringPiece> new_matches = FindMatchingSelectors(frame);
    120   std::vector<base::StringPiece>& old_matches = matching_selectors_[frame];
    121   if (new_matches == old_matches)
    122     return;
    123 
    124   using std::swap;
    125   swap(old_matches, new_matches);
    126   NotifyBrowserOfChange(frame);
    127 }
    128 
    129 std::vector<base::StringPiece> ContentWatcher::FindMatchingSelectors(
    130     WebKit::WebFrame* frame) const {
    131   std::vector<base::StringPiece> result;
    132   v8::HandleScope scope;
    133 
    134   // Get the indices within |css_selectors_| that match elements in
    135   // |frame|, as a JS Array.
    136   v8::Local<v8::Value> selector_indices;
    137   if (ModuleSystem* module_system = GetModuleSystem(frame)) {
    138     v8::Context::Scope context_scope(frame->mainWorldScriptContext());
    139     v8::Local<v8::Array> js_css_selectors =
    140         v8::Array::New(css_selectors_.size());
    141     for (size_t i = 0; i < css_selectors_.size(); ++i) {
    142       js_css_selectors->Set(i, v8::String::New(css_selectors_[i].data(),
    143                                                css_selectors_[i].size()));
    144     }
    145     std::vector<v8::Handle<v8::Value> > find_selectors_args;
    146     find_selectors_args.push_back(js_css_selectors);
    147     selector_indices = module_system->CallModuleMethod("contentWatcher",
    148                                                        "FindMatchingSelectors",
    149                                                        &find_selectors_args);
    150   }
    151   if (selector_indices.IsEmpty() || !selector_indices->IsArray())
    152     return result;
    153 
    154   // Iterate over the array, and extract the indices, laboriously
    155   // converting them back to integers.
    156   v8::Local<v8::Array> index_array = selector_indices.As<v8::Array>();
    157   const size_t length = index_array->Length();
    158   result.reserve(length);
    159   for (size_t i = 0; i < length; ++i) {
    160     v8::Local<v8::Value> index_value = index_array->Get(i);
    161     if (!index_value->IsNumber())
    162       continue;
    163     double index = index_value->NumberValue();
    164     // Make sure the index is within bounds.
    165     if (index < 0 || css_selectors_.size() <= index)
    166       continue;
    167     // Push a StringPiece referring to the CSS selector onto the result.
    168     result.push_back(
    169         base::StringPiece(css_selectors_[static_cast<size_t>(index)]));
    170   }
    171   return result;
    172 }
    173 
    174 void ContentWatcher::NotifyBrowserOfChange(
    175     WebKit::WebFrame* changed_frame) const {
    176   WebKit::WebFrame* const top_frame = changed_frame->top();
    177   const WebKit::WebSecurityOrigin top_origin =
    178       top_frame->document().securityOrigin();
    179   // Want to aggregate matched selectors from all frames where an
    180   // extension with access to top_origin could run on the frame.
    181   if (!top_origin.canAccess(changed_frame->document().securityOrigin())) {
    182     // If the changed frame can't be accessed by the top frame, then
    183     // no change in it could affect the set of selectors we'd send back.
    184     return;
    185   }
    186 
    187   std::set<base::StringPiece> transitive_selectors;
    188   for (WebKit::WebFrame* frame = top_frame; frame;
    189        frame = frame->traverseNext(/*wrap=*/false)) {
    190     if (top_origin.canAccess(frame->document().securityOrigin())) {
    191       std::map<WebKit::WebFrame*,
    192                std::vector<base::StringPiece> >::const_iterator
    193           frame_selectors = matching_selectors_.find(frame);
    194       if (frame_selectors != matching_selectors_.end()) {
    195         transitive_selectors.insert(frame_selectors->second.begin(),
    196                                     frame_selectors->second.end());
    197       }
    198     }
    199   }
    200   std::vector<std::string> selector_strings;
    201   for (std::set<base::StringPiece>::const_iterator
    202            it = transitive_selectors.begin();
    203        it != transitive_selectors.end(); ++it)
    204     selector_strings.push_back(it->as_string());
    205   content::RenderView* view =
    206       content::RenderView::FromWebView(top_frame->view());
    207   view->Send(new ExtensionHostMsg_OnWatchedPageChange(
    208       view->GetRoutingID(), selector_strings));
    209 }
    210 
    211 }  // namespace extensions
    212