Greasemonkey support.

chrome/browser/web_contents.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/web_contents.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/path_service.h"
+#include "base/singleton.h"
+#include "base/string_util.h"
+#include "net/base/escape.h"
+#include "chrome/common/chrome_paths.h"
+#include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/cache_manager_host.h"
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/find_in_page_controller.h"
 #include "chrome/browser/find_notification_details.h"
@@ skipping 127 matching lines @@
 }
 
 // Returns true if the entry's transition type is FORM_SUBMIT.
 bool IsFormSubmit(const NavigationEntry* entry) {
   return (PageTransition::StripQualifier(entry->transition_type()) ==
           PageTransition::FORM_SUBMIT);
 }
 
 }  // namespace
 
+class GreaseMonkeyScript {
+public:
+  GreaseMonkeyScript(const std::wstring& path)
+    : path_(path) {}
+
+  bool Parse(const std::string& content) {
+    // http://wiki.greasespot.net/Metadata_block
+    std::map<std::string, std::string> keyvals;
+    std::vector<std::string> lines;
+    SplitString(content, '\n', &lines);
+    bool in_metadata = false;
+    for (std::vector<std::string>::iterator i = lines.begin(); i != lines.end(); ++i) {
+      std::string line;
+      TrimWhitespace(*i, TRIM_ALL, &line);
+      if (line == "// ==UserScript==") {
+        in_metadata = true;
+      } else if (in_metadata) {
+        if (line == "// ==/UserScript==")
+          break;
+        std::vector<std::string> parts;
+        SplitString(line, ' ', &parts);
+        if (parts.size() > 3) {
+          for (size_t i = 3; i < parts.size(); ++i) {
+            parts[2] += " " + parts[i];
+          }
+          parts.resize(3);
+        }
+        if (parts.size() == 3 && parts[0] == "//") {
+          std::string key = parts[1];
+          if (key.length() > 0 && key[0] == '@')
+            key = key.substr(1);
+          std::string value;
+          TrimWhitespace(parts[2], TRIM_ALL, &value);
+          if (key == "include") {
+            include_globs_.push_back(value);
+          } else {
+            //NOTREACHED();
+          }
+        }
+      }
+    }
+    script_ = content;
+    return true;
+  }
+
+  bool AffectsURL(const GURL& url) {
+    const std::string& spec = url.spec();
+    for (std::vector<std::string>::const_iterator glob = include_globs_.begin();
+         glob != include_globs_.end(); ++glob) {
+      for (size_t i = 0; i < glob->size(); ++i) {
+        char glob_char = (*glob)[i];
+        if (glob_char == '*' && i == glob->size() - 1)
+          return true;
+        if (i > spec.size() || spec[i] != glob_char)
+          return false;
+      }
+    }
+    return true;
+  }
+
+  std::string script() const {
+    return script_;
+  }
+
+  std::wstring path() const {
+    return path_;
+  }
+
+  std::vector<std::string> include_globs_;
+  std::string script_;
+  std::wstring path_;
+};
+
+class ScriptInjector {
+public:
+  ScriptInjector() {
+    LoadUserScripts();
+  }
+
+  ~ScriptInjector() {
+    ClearScripts();
+  }
+
+  void ClearScripts() {
+    for (std::vector<GreaseMonkeyScript*>::iterator script = scripts_.begin();
+         script != scripts_.end(); ++script) {
+      delete *script;
+    }
+    scripts_.clear();
+  }
+
+  void LoadUserScripts() {
+    ClearScripts();
+    std::wstring path;
+    DCHECK(PathService::Get(chrome::DIR_USER_SCRIPTS, &path));
+    file_util::FileEnumerator enumerator(path, false, file_util::FileEnumerator::FILES,
+                                         L"*.user.js");
+    for (std::wstring file = enumerator.Next(); !file.empty(); file = enumerator.Next()) {
+      std::string contents;
+      DCHECK(file_util::ReadFileToString(file, &contents));
+      GreaseMonkeyScript* script = new GreaseMonkeyScript(file);
+      DCHECK(script->Parse(contents));
+      scripts_.push_back(script);
+      //url_js_["http://" + WideToUTF8(file_util::GetFilenameFromPath(file)) + "/"] = UTF8ToWide(contents);
+    }
+  }
+
+  void LoadCompleted(WebContents* web_contents) {
+    LoadUserScripts();
+    NavigationEntry* nav_entry = web_contents->controller()->GetActiveEntry();
+    DCHECK(nav_entry);
+    for (std::vector<GreaseMonkeyScript*>::const_iterator script = scripts_.begin();
+         script != scripts_.end(); ++script) {
+      if ((*script)->AffectsURL(nav_entry->url())) {
+        RunJavaScript(web_contents, (*script)->script(), (*script)->path());
+      }
+    }
+  }
+
+  void RunJavaScript(WebContents* web_contents, const std::string& javascript,
+                     const std::wstring& path) {
+    web_contents->render_view_host()->ExecuteJavascriptInWebFrame(std::wstring(),
+                                                                  UTF8ToWide(javascript),
+                                                                  path);
+  }
+
+  std::vector<GreaseMonkeyScript*> scripts_;
+};
+Singleton<ScriptInjector> script_injector;
+
+
 class WebContents::GearsCreateShortcutCallbackFunctor {
  public:
   explicit GearsCreateShortcutCallbackFunctor(WebContents* contents)
      : contents_(contents) {}
 
   void Run(const GearsShortcutData& shortcut_data, bool success) {
     if (contents_)
       contents_->OnGearsCreateShortcutDone(shortcut_data, success);
     delete this;
   }
@@ skipping 947 matching lines @@
           "available in OnMsgDidStopLoading unless we are loading the "
           "initial blank page.";
     }
   }
 
   // Tell PasswordManager we've finished a page load, which serves as a
   // green light to save pending passwords and reset itself.
   GetPasswordManager()->DidStopLoading();
 
   SetIsLoading(false, details.get());
+  script_injector->LoadCompleted(this);
 }
 
 void WebContents::DidStartProvisionalLoadForFrame(
     RenderViewHost* render_view_host,
     bool is_main_frame,
     const GURL& url) {
   ProvisionalLoadDetails details(
       is_main_frame,
       render_manager_.IsRenderViewInterstitial(render_view_host),
       controller()->IsURLInPageNavigation(url),
@@ skipping 1176 matching lines @@
     // The favicon url isn't valid. This means there really isn't a favicon,
     // or the favicon url wasn't obtained before the load started. This assumes
     // the later.
     // TODO(sky): Need a way to set the favicon that doesn't involve generating
     // its url.
     new_url->SetFavIconURL(TemplateURL::GenerateFaviconURL(params.referrer));
   }
   new_url->set_safe_for_autoreplace(true);
   url_model->Add(new_url);
 }