diff -up8rN /dev/null mozilla/extensions/bayesiantest/Makefile.in
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/Makefile.in	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,50 @@
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is mozilla.org code.
+#
+# Contributor(s):
+#   O. Atsushi <torisugari@gmail.com>
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+DEPTH            = ../..
+topsrcdir        = @top_srcdir@
+srcdir           = @srcdir@
+VPATH            = @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= bayesiantest
+DIRS		= public src resources locales
+
+EXTRA_PP_COMPONENTS =	mozBayesianTestDataSource.js \
+			$(NULL)
+
+ifeq ($(MOZ_BUILD_APP),browser)
+DIRS		+= debugui
+endif
+
+include $(topsrcdir)/config/rules.mk
diff -up8rN /dev/null mozilla/extensions/bayesiantest/debugui/Makefile.in
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/debugui/Makefile.in	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,41 @@
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is mozilla.org code.
+#
+# Contributor(s):
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+include $(topsrcdir)/config/rules.mk
diff -up8rN /dev/null mozilla/extensions/bayesiantest/debugui/content/browserOverlay.js
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/debugui/content/browserOverlay.js	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,26 @@
+/* XXX This is a ultra dirty hack. ********************************************/
+nsBrowserStatusHandler.prototype.asyncUpdateUI__original__
+= nsBrowserStatusHandler.prototype.asyncUpdateUI;
+nsBrowserStatusHandler.prototype.asyncUpdateUI = function (){
+  setTimeout(__bayesiantest_debug_updateUI, 200);
+  this.asyncUpdateUI__original__();
+};
+/******************************************************************************/
+function __bayesiantest_debug_updateUI() {
+  var commandID = document.getElementById("sidebar-box")
+                          .getAttribute("sidebarcommand");
+  if (commandID != "viewTrainingManagerSidebar")
+    return;
+  var sidebar = document.getElementById("sidebar");
+  var currentURI = sidebar.contentDocument.getElementById("uri-area").value;
+  var currentText = sidebar.contentDocument.getElementById("content-area").value;
+  var newURI = content.location.href;
+  var newText = (content.document.body)? content.document.body.textContent : null;
+  if (newText && (newText != currentText)) {
+    sidebar.contentDocument.getElementById("uri-area").value = newURI;
+    sidebar.contentDocument.getElementById("content-area").value = newText;
+    sidebar.contentWindow.dispatchTestEvent();
+  }
+}
+/******************************************************************************/
+
diff -up8rN /dev/null mozilla/extensions/bayesiantest/debugui/content/browserOverlay.xul
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/debugui/content/browserOverlay.xul	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<!DOCTYPE window SYSTEM "chrome://bayesiantest/locale/">
+
+<overlay id="bayesiantestdebug-browser-overlay"
+         xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+
+  <script type="application/x-javascript" src="chrome://bayesiantestdebug/content/browserOverlay.js"/>
+  <broadcasterset id="mainBroadcasterSet">
+    <broadcaster id="viewTrainingManagerSidebar" autoCheck="false" label="&bayesiantest.window.title;"
+                 type="checkbox" group="sidebar" sidebarurl="chrome://bayesiantest/content/"
+                 oncommand="toggleSidebar('viewTrainingManagerSidebar'); setTimeout(__bayesiantest_debug_updateUI, 200);"/>
+  </broadcasterset>
+  <menupopup id="viewSidebarMenu">
+    <menuitem observes="viewTrainingManagerSidebar" accesskey="T"/>
+  </menupopup>
+</overlay>
diff -up8rN /dev/null mozilla/extensions/bayesiantest/debugui/jar.mn
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/debugui/jar.mn	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,5 @@
+bayesiantestdebug.jar:
+%  content bayesiantestdebug %content/bayesiantestdebug/ xpcnativewrappers=yes
+%  overlay chrome://browser/content/browser.xul chrome://bayesiantestdebug/content/browserOverlay.xul
+  content/bayesiantestdebug/browserOverlay.xul        (content/browserOverlay.xul)
+  content/bayesiantestdebug/browserOverlay.js        (content/browserOverlay.js)
diff -up8rN /dev/null mozilla/extensions/bayesiantest/locales/Makefile.in
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/locales/Makefile.in	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,47 @@
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is the Mozilla Browser code.
+#
+# The Initial Developer of the Original Code is
+# Benjamin Smedberg <bsmedberg@covad.net>
+# Portions created by the Initial Developer are Copyright (C) 2004
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+DEPTH          = ../../..
+topsrcdir      = @top_srcdir@
+srcdir         = @srcdir@
+VPATH          = @srcdir@
+relativesrcdir = extensions/bayesiantest/locales
+
+include $(DEPTH)/config/autoconf.mk
+
+DEFINES += -DAB_CD=$(AB_CD)
+
+include $(topsrcdir)/config/rules.mk
diff -up8rN /dev/null mozilla/extensions/bayesiantest/locales/en-US/chrome/bayesiantest.dtd
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/locales/en-US/chrome/bayesiantest.dtd	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,34 @@
+<!ENTITY bayesiantest.window.title "Training Manager">
+
+<!ENTITY bayesiantest.add.label "Add a new topic...">
+<!ENTITY bayesiantest.add.accesskey "A">
+
+<!ENTITY bayesiantest.delete.label "Delete">
+<!ENTITY bayesiantest.delete.accesskey "D">
+
+<!ENTITY bayesiantest.train.label "Train">
+<!ENTITY bayesiantest.train.accesskey "T">
+
+<!ENTITY bayesiantest.test.label "Test">
+<!ENTITY bayesiantest.test.accesskey "e">
+
+<!ENTITY bayesiantest.properties.label "Properties">
+<!ENTITY bayesiantest.properties.accesskey "d">
+
+<!ENTITY bayesiantest.radio.positive.label "Positive">
+<!ENTITY bayesiantest.radio.negative.label "Negative">
+<!ENTITY bayesiantest.radio.skip.label     "Skip">
+
+<!ENTITY bayesiantest.topic.label "?topic">
+<!ENTITY bayesiantest.score.label "Please wait a minute...">
+
+<!ENTITY bayesiantest.properties.title "Database Properties">
+<!ENTITY bayesiantest.properties.show "Show all tokens">
+<!ENTITY bayesiantest.properties.filesize "File Size:">
+<!ENTITY bayesiantest.properties.positive.label "Number of positive tokens:">
+<!ENTITY bayesiantest.properties.negative.label "Number of negative tokens:">
+<!ENTITY bayesiantest.properties.positive.accesskey "p">
+<!ENTITY bayesiantest.properties.negative.accesskey "n">
+<!ENTITY bayesiantest.properties.positivedocuments "List of positive documents">
+<!ENTITY bayesiantest.properties.negativedocuments "List of negative documents">
+
diff -up8rN /dev/null mozilla/extensions/bayesiantest/locales/en-US/chrome/bayesiantest.properties
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/locales/en-US/chrome/bayesiantest.properties	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,4 @@
+defaultScore=Please wait a minute...
+formattedScore=Score: %S
+addDialogText=Please input a new title.
+deleteDialogText=Are you sure to discard the database about "%S"?
diff -up8rN /dev/null mozilla/extensions/bayesiantest/locales/jar.mn
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/locales/jar.mn	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,11 @@
+#if 0
+@AB_CD@.jar:
+% locale bayesiantest @AB_CD@ %locale/@AB_CD@/bayesiantest/
+  locale/@AB_CD@/bayesiantest/bayesiantest.dtd                  (%chrome/bayesiantest.dtd)
+  locale/@AB_CD@/bayesiantest/bayesiantest.properties           (%chrome/bayesiantest.properties)
+#else
+bayesiantest.jar:
+% locale bayesiantest en-US %locale/en-US/bayesiantest/
+  locale/en-US/bayesiantest/bayesiantest.dtd                  (en-US/chrome/bayesiantest.dtd)
+  locale/en-US/bayesiantest/bayesiantest.properties           (en-US/chrome/bayesiantest.properties)
+#endif
diff -up8rN /dev/null mozilla/extensions/bayesiantest/mozBayesianTestDataSource.js
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/mozBayesianTestDataSource.js	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,364 @@
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is mozilla.org code.
+#
+# Contributor(s):
+#   O. Atsushi <torisugari@gmail.com>
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+const COMPONENT_CONTRACTID = "@mozilla.org/rdf/datasource;1?name=bayesiantest";
+const COMPONENT_CID = Components.ID("{12a14ea8-b97d-ad61-cca5-2d8b5eb03b3b}");
+const COMPONENT_PRETTY_NAME = "Bayesiantest DataSource";
+
+const SQLITE_FILE_EXPRESSION =
+/^(\{[0-9a-f]{8}\-[0-9a-f]{4}\-[0-9a-f]{4}\-[0-9a-f]{4}\-[0-9a-f]{12}\})\.sqlite$/m;
+const RDF_TOPIC_ARC =
+"http://www.mozilla.org/mozilla/extensions/bayesiantest/#topic";
+const RDF_DELETE_ARC =
+"http://www.mozilla.org/mozilla/extensions/bayesiantest/#delete";
+const RDF_TOPIC_CONTAINER =
+"urn:mozilla/extensions/bayesiantest:root";
+
+var gComponent = {
+  mDataSource : null,
+
+  init: function comp_init () {
+    if (this.mDataSource)
+      return;
+    var rdfService =
+      Components.classes["@mozilla.org/rdf/rdf-service;1"]
+                .getService(Components.interfaces.nsIRDFService);
+
+    var file = Components.classes["@mozilla.org/file/directory_service;1"]
+                         .getService(Components.interfaces.nsIProperties)
+                         .get("ProfD", Components.interfaces.nsIFile);
+    file.append("bayesiantest.rdf");
+
+    if (!file.exists())
+      file.create(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, 0666);
+    var ioService = Components.classes["@mozilla.org/network/io-service;1"]
+                              .getService(Components.interfaces.nsIIOService);
+    var uri = ioService.newFileURI(file).spec;
+    this.mDataSource = rdfService.GetDataSourceBlocking(uri);
+
+    /* clean up sqlite files. */
+    var folder = Components.classes["@mozilla.org/file/directory_service;1"]
+                           .getService(Components.interfaces.nsIProperties)
+                           .get("ProfD", Components.interfaces.nsIFile);
+    folder.append("bayesian");
+    if (!folder.exists())
+      return;
+    var files = folder.directoryEntries;
+    var topicArc = rdfService.GetResource(RDF_TOPIC_ARC);
+    var deleteArc = rdfService.GetResource(RDF_DELETE_ARC);
+    var deleteVal = rdfService.GetLiteral("true");
+    var rootContainer = this.mTopicContainer;
+    while(files.hasMoreElements()) {
+      file = files.getNext().QueryInterface(Components.interfaces.nsIFile);
+      if (SQLITE_FILE_EXPRESSION.test(file.leafName)) {
+        var resource = rdfService.GetResource("urn:" + RegExp.$1);
+        var target = this.mDataSource.GetTarget(resource, topicArc, true);
+        if (!target) {
+          target = this.mDataSource.GetTarget(resource, deleteArc, true);
+          if (target) {
+            this.mDataSource.Unassert(resource, deleteArc, target, true);
+            try {
+              file.remove(false);
+            }
+            catch (e) {}
+          }
+          else {
+              target = rdfService.GetLiteral("{Unknown Database}");
+            this.mDataSource.Assert(resource, topicArc, target, true);
+            if (rootContainer.IndexOf(resource) < 0)
+              rootContainer.AppendElement(resource);
+          }
+        }
+      }
+    }
+
+    var source = this.mDataSource.GetSource(deleteArc, deleteVal, true);
+    while (source) {
+      this.mDataSource.Unassert(source, deleteArc, deleteVal, true);
+      source = this.mDataSource.GetSource(deleteArc, deleteVal, true);
+    }
+    Components.classes["@mozilla.org/observer-service;1"]
+              .getService(Components.interfaces.nsIObserverService)
+              .addObserver(this, "xpcom-shutdown", false);
+  },
+
+  get observerService() {
+    return;
+  },
+
+  shutdown: function comp_shutdown () {
+    this.mDataSource = null;
+  },
+
+  get mTopicContainer() {
+    var rdfService = Components.classes["@mozilla.org/rdf/rdf-service;1"]
+                               .getService(Components.interfaces.nsIRDFService);
+
+    var rdfContainerUtils =
+      Components.classes["@mozilla.org/rdf/container-utils;1"]
+                .getService(Components.interfaces.nsIRDFContainerUtils);
+
+    var container = null;
+    var resource = rdfService.GetResource(RDF_TOPIC_CONTAINER);
+
+    if (rdfContainerUtils.IsContainer(this.mDataSource, resource)) {
+      container =
+        Components.classes["@mozilla.org/rdf/container;1"]
+                  .createInstance(Components.interfaces.nsIRDFContainer);
+      container.Init(this.mDataSource, resource);
+    }
+    else {
+      container = rdfContainerUtils.MakeSeq(this.mDataSource, resource);
+    }
+
+    return container;
+  },
+
+  get newUUID() {
+    function randomNum(aLoop) {
+      var num = "";
+      for (var i = 0; i < aLoop; i++)
+        num += parseInt(Math.random() * 0x0F).toString(16);
+      return num;
+    }
+
+    return "{" +
+           randomNum(8) + "-" +
+           randomNum(4) + "-" +
+           randomNum(4) + "-" +
+           randomNum(4) + "-" +
+           randomNum(12) + "}";
+  },
+
+  get URI() {
+    return "rdf:bayesiantest";
+  },
+
+  get loaded() {
+    return (this.mDataSource)? true : false;
+  }
+};
+
+gComponent.createTopic = function (aTopic) {
+  var rdfService = Components.classes["@mozilla.org/rdf/rdf-service;1"]
+                             .getService(Components.interfaces.nsIRDFService);
+  var topicArc = rdfService.GetResource(RDF_TOPIC_ARC);
+  var topicValue = rdfService.GetLiteral(aTopic);
+
+  var source = this.mDataSource.GetSource(topicArc, topicValue, true);
+
+  if (!source) {
+    source = rdfService.GetResource("urn:" + this.newUUID);
+    this.mDataSource.Assert(source, topicArc, topicValue, true);
+  }
+
+  var rootContainer = this.mTopicContainer;
+  if (rootContainer.IndexOf(source) < 0)
+    rootContainer.AppendElement(source);
+
+  return source;
+};
+
+gComponent.changeTopic = function (aResource, aNewTopic) {
+};
+
+gComponent.deleteTopic = function (aResource) {
+  var rdfService = Components.classes["@mozilla.org/rdf/rdf-service;1"]
+                             .getService(Components.interfaces.nsIRDFService);
+  var topicArc = rdfService.GetResource(RDF_TOPIC_ARC);
+
+  var target = this.mDataSource.GetTarget(aResource, topicArc, true);
+
+  if (target)
+    this.mDataSource.Unassert(aResource, topicArc, target, true);
+
+  var rootContainer = this.mTopicContainer;
+  if (rootContainer.IndexOf(aResource) > -1)
+    rootContainer.RemoveElement(aResource, true);
+
+  var deleteArc = rdfService.GetResource(RDF_DELETE_ARC);
+  var deleteValue = rdfService.GetLiteral("true");
+
+  target = this.mDataSource.GetTarget(aResource, topicArc, true);
+  if (!target)
+    this.mDataSource.Assert(aResource, deleteArc, deleteValue, true);
+};
+
+/* RDF DATASOURCE */
+gComponent.DoCommand = function (sources, command, arguments) {
+  throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+};
+gComponent.GetAllCmds = function (source) {
+  throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+};
+gComponent.IsCommandEnabled = function (sources, command, arguments) {
+  throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+};
+
+gComponent.AddObserver = function (observer) {
+  return this.mDataSource.AddObserver(observer);
+};
+gComponent.RemoveObserver = function (observer) {
+  return this.mDataSource.RemoveObserver(observer);
+};
+gComponent.endUpdateBatch = function () {
+  return this.mDataSource.endUpdateBatch();
+};
+gComponent.beginUpdateBatch = function () {
+  return this.mDataSource.beginUpdateBatch();
+};
+gComponent.ArcLabelsIn = function (node) {
+  return this.mDataSource.ArcLabelsIn(node);
+};
+gComponent.ArcLabelsOut = function (source) {
+  return this.mDataSource.ArcLabelsOut(source);
+};
+gComponent.Assert = function (source, property, target, truthValue) {
+  return this.mDataSource.Assert(source, property, target, truthValue);
+};
+gComponent.Change = function (source, property, oldTarget, newTarget) {
+  return this.mDataSource.Change(source, property, oldTarget, newTarget);
+};
+gComponent.GetAllResources = function () {
+  return this.mDataSource.GetAllResources();
+};
+gComponent.GetSource = function (property, target, truthValue) {
+  return this.mDataSource.GetSource(property, target, truthValue);
+};
+gComponent.GetSources = function (property, target, truthValue) {
+  return this.mDataSource.GetSources(property, target, truthValue);
+};
+gComponent.GetTarget = function (source, property, truthValue) {
+  return this.mDataSource.GetTarget(source, property, truthValue);
+};
+gComponent.GetTargets = function (source, property, truthValue) {
+  return this.mDataSource.GetTargets(source, property, truthValue);
+};
+gComponent.hasArcIn = function (node, arc) {
+  return this.mDataSource.hasArcIn(node, arc);
+};
+gComponent.hasArcOut = function (source, arc) {
+  return this.mDataSource.hasArcOut(source, arc);
+};
+gComponent.HasAssertion = function (source, property, target, truthValue) {
+  return this.mDataSource.HasAssertion(source, property, target, truthValue);
+};
+gComponent.Move = function (oldSource, newSource, property, target) {
+  return this.mDataSource.Move(oldSource, newSource, property, target);
+};
+gComponent.Unassert = function (source, property, target) {
+  return this.mDataSource.Unassert(source, property, target);
+};
+/* RDF DATASOURCE */
+
+gComponent.flush = function () {
+  return this.mDataSource
+             .QueryInterface(Components.interfaces.nsIRDFRemoteDataSource)
+             .Flush();
+}
+
+/* nsISupports */
+gComponent.QueryInterface = function(aIID) {
+  if (aIID.equals(Components.interfaces.nsIRDFDataSource))
+    this.init();
+  if (aIID.equals(Components.interfaces.nsISupports) ||
+      aIID.equals(Components.interfaces.nsIRDFDataSource) ||
+      aIID.equals(Components.interfaces.nsIObserver) ||
+      aIID.equals(Components.interfaces.mozIBayesianTestUtils) ||
+      aIID.equals(Components.interfaces.nsIFactory)) {
+    return this;
+  }
+  throw Components.results.NS_ERROR_NO_INTERFACE;
+  return null;
+};
+
+/* nsIObserver */
+gComponent.observe = function (aSubject, aTopic, aData) {
+  if (aTopic == "app-startup") {
+    this.init();
+  } else if(aTopic == "xpcom-shutdown") {
+    this.shutdown();
+  }
+};
+
+/* nsIFactory */
+gComponent.createInstance = function (aOuter, aIID) {
+  if (aOuter != null)
+    throw Components.results.NS_ERROR_NO_AGGREGATION;
+
+  return this.QueryInterface(aIID);
+};
+
+gComponent.lockFactory = function (aLock) {};
+
+var gModule = {
+  /* nsISupports */
+  QueryInterface: function mod_QI(aIID) {
+    if (aIID.equals(Components.interfaces.nsIModule) ||
+        aIID.equals(Components.interfaces.nsISupports))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  /* nsIModule */
+  getClassObject: function mod_getco(compMgr, cid, iid) {
+    if (cid.equals(COMPONENT_CID))
+      return gComponent.QueryInterface(iid);
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  registerSelf: function mod_reg(aCompMgr, aFileSpec, aLocation, aType) {
+    var compReg =
+      aCompMgr.QueryInterface( Components.interfaces.nsIComponentRegistrar);
+
+    compReg.registerFactoryLocation( COMPONENT_CID,
+                                     COMPONENT_PRETTY_NAME,
+                                     COMPONENT_CONTRACTID,
+                                     aFileSpec, aLocation, aType );
+  },
+
+  unregisterSelf : function mod_unreg(aCompMgr, aLocation, aType) {
+    var compReg = aCompMgr.QueryInterface(nsIComponentRegistrar);
+    compReg.unregisterFactoryLocation(COMPONENT_CID, aLocation);
+  },
+
+  canUnload: function(compMgr) {
+    return true;
+  }
+};
+
+// NSGetModule: Return the nsIModule object.
+function NSGetModule(compMgr, fileSpec) {
+  return gModule;
+}
diff -up8rN /dev/null mozilla/extensions/bayesiantest/public/Makefile.in
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/public/Makefile.in	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,46 @@
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is mozilla.org code.
+#
+# Contributor(s):
+#   O. Atushsi <torisugari@gmail.com>
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+DEPTH            = ../../..
+topsrcdir        = @top_srcdir@
+srcdir           = @srcdir@
+VPATH            = @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= bayesiantest
+
+XPIDLSRCS	= mozIBayesianTester.idl  \
+		  $(NULL)
+
+include $(topsrcdir)/config/rules.mk
+
diff -up8rN /dev/null mozilla/extensions/bayesiantest/public/mozIBayesianTester.idl
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/public/mozIBayesianTester.idl	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include "nsISupports.idl"
+#include "nsIStringEnumerator.idl"
+
+interface nsIFile;
+interface nsIObserver;
+interface nsIRDFResource;
+
+[scriptable, uuid(dff3e4c9-6a20-40a5-aa11-163728332b86)]
+interface mozIPlainTextTokenizer : nsIUTF8StringEnumerator {
+  void initialize(in AString aDocument, in PRUint32 aMaxTokens);
+};
+
+[scriptable, uuid(9285a637-53f9-4353-bd9e-bded9bc2d36d)]
+interface mozIBayesianTester : nsISupports {
+  double test(in AString aDocument);
+  void train(in AUTF8String aURISpec,
+             in AString aDocument,
+             in boolean aIsPositive);
+
+  /* for UI displays */
+  readonly attribute nsIFile database;
+  readonly attribute PRInt32 positiveTokenCount;
+  readonly attribute PRInt32 negativeTokenCount;
+  readonly attribute AUTF8String positiveDocuments;
+  readonly attribute AUTF8String negativeDocuments;
+  readonly attribute AUTF8String positiveTokens;
+  readonly attribute AUTF8String negativeTokens;
+
+  /* config */
+  attribute double strength;
+  attribute double assumedProbability;
+
+  attribute mozIPlainTextTokenizer tokenizer;
+
+  /* utl */
+  PRInt32 trimOldTokens(in PRBool aTargetIsPositiveTable,
+                        in PRInt32 aMaxTokens,
+                        in PRInt32 aThresholdCounts);
+};
+
+[scriptable, uuid(9285a639-53f9-4353-bd9e-bded9bc2d36d)]
+interface mozIBayesianTestee : nsISupports {
+  const unsigned short MODE_TEST     = 0x01;
+  const unsigned short MODE_TRAIN    = 0x02;
+  const unsigned short MODE_CANCELED = 0x04;
+
+  const unsigned short VALUE_POSITIVE = 0x10;
+
+  /* Query params */
+  attribute unsigned short mode;
+  attribute ACString testerID;
+  attribute AUTF8String documentID;
+  attribute AString documentBody;
+
+  /* Query results */
+  attribute double result;
+};
+
+[scriptable, uuid(fb438388-715f-48fc-A6ff-7bc075ff2c58)]
+interface mozIBayesianTestService : nsISupports
+{
+  mozIBayesianTester createTester(in nsIFile aDBFile);
+  mozIBayesianTester createTesterFromAlias(in ACString aTesterID);
+  void testAsync(in ACString aAlias,
+                 in AUTF8String aURISpec,
+                 in AString aDocument);
+  void trainAsync(in ACString aAlias,
+                  in AUTF8String aURISpec,
+                  in AString aDocument,
+                  in boolean aIsPositive);
+};
+
+[scriptable, uuid(d5d8d85c-7665-13a0-5b52-82e23ad75d65)]
+interface mozIBayesianTestUtils : nsISupports
+{
+  nsIRDFResource createTopic(in AString aTopic);
+  void changeTopic(in nsIRDFResource aResource, in AString aNewTopic);
+  void deleteTopic(in nsIRDFResource aResource);
+  void flush();
+};
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/Makefile.in
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/Makefile.in	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,43 @@
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is mozilla.org code.
+#
+# Contributor(s):
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+DEFINES += -DAB_CD=$(AB_CD)
+
+include $(topsrcdir)/config/rules.mk
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/content/bayesiantest-dump.js
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/content/bayesiantest-dump.js	2006-12-03 20:41:05.000000000 +0900
@@ -0,0 +1,14 @@
+function startup(aEvent) {
+  if(!window.arguments || !window.arguments[0])
+    return;
+
+  var testService =
+    Components.classes["@mozilla.org/extensions/bayesiantest/gr;1"]
+              .getService(Components.interfaces.mozIBayesianTestService);
+  var tester = testService.createTesterFromAlias(window.arguments[0]);
+
+  if (window.arguments[1])
+    document.getElementById("dump").value = tester.positiveTokens;
+  else
+    document.getElementById("dump").value = tester.negativeTokens;
+}
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/content/bayesiantest-dump.xul
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/content/bayesiantest-dump.xul	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+<?xml-stylesheet href="chrome://bayesiantest/content/bayesiantest.css" type="text/css"?>
+<!DOCTYPE window SYSTEM "chrome://bayesiantest/locale/">
+<window id="bayesiant-dump-window"
+        title="&bayesiantest.window.title;"
+        orient="vertical"
+        xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        onload="startup()"
+        persist="width height">
+
+  <script type="application/x-javascript"
+          src="chrome://bayesiantest/content/bayesiantest-dump.js"/>
+  <textbox id="dump" multiline="true" readonly="true" flex="1"/>
+</window>
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/content/bayesiantest-properties.js
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/content/bayesiantest-properties.js	2006-12-03 20:36:29.000000000 +0900
@@ -0,0 +1,22 @@
+function startup(aEvent) {
+  if(!window.arguments || !window.arguments[0])
+    return;
+
+  var testService =
+    Components.classes["@mozilla.org/extensions/bayesiantest/gr;1"]
+              .getService(Components.interfaces.mozIBayesianTestService);
+  var tester = testService.createTesterFromAlias(window.arguments[0]);
+  document.getElementById("file-size").value =
+    (tester.database.fileSize/1024) + "KiB";
+  document.getElementById("positive-count").value = tester.positiveTokenCount;
+  document.getElementById("negative-count").value = tester.negativeTokenCount;
+  document.getElementById("positive-list").value = tester.positiveDocuments;
+  document.getElementById("negative-list").value = tester.negativeDocuments;
+}
+
+function showAll(aIsPositive) {
+
+  openDialog("chrome://bayesiantest/content/bayesiantest-dump.xul",
+             "_blank", "chrome,dialog=no,all",
+             window.arguments[0], aIsPositive);
+}
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/content/bayesiantest-properties.xul
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/content/bayesiantest-properties.xul	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,56 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+<?xml-stylesheet href="chrome://bayesiantest/content/bayesiantest.css" type="text/css"?>
+<!DOCTYPE window SYSTEM "chrome://bayesiantest/locale/">
+<window id="bayesiant-properties-window"
+        title="&bayesiantest.properties.title;"
+        orient="vertical"
+        xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        onload="startup()"
+        persist="width height">
+
+  <script type="application/x-javascript"
+          src="chrome://bayesiantest/content/bayesiantest-properties.js"/>
+  <grid>
+    <columns>
+      <column/>
+      <column flex="1"/>
+    </columns>
+    <rows>
+      <row>
+        <label value ="&bayesiantest.properties.filesize;"/>
+        <textbox id="file-size" readonly="true"/>
+      </row>
+      <row>
+        <label value ="&bayesiantest.properties.positive.label;"
+               accesskey="&bayesiantest.properties.positive.accesskey;"
+               control="show-positive"/>
+        <hbox flex="1">
+          <textbox id="positive-count" readonly="true" flex="1"/>
+          <button id="show-positive"
+                  label="&bayesiantest.properties.show;"
+                  oncommand="showAll(true);"/>
+        </hbox>
+      </row>
+      <row>
+        <label value ="&bayesiantest.properties.negative.label;"
+               accesskey="&bayesiantest.properties.negative.accesskey;"
+               control="show-negative"/>
+        <hbox flex="1">
+          <textbox id="negative-count" readonly="true" flex="1"/>
+          <button id="show-negative"
+                  label="&bayesiantest.properties.show;" oncommand="showAll(false);"/>
+        </hbox>
+      </row>
+    </rows>
+  </grid>
+  <groupbox id="positive-group" orient="vertical">
+    <caption label="&bayesiantest.properties.positivedocuments;"/>
+    <textbox id="positive-list" multiline="true" rows="4" readonly="true"/>
+  </groupbox>
+  <groupbox id="negative-group" orient="vertical">
+    <caption label="&bayesiantest.properties.negativedocuments;"/>
+    <textbox id="negative-list" multiline="true" rows="4" readonly="true"/>
+  </groupbox>
+</window>
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/content/bayesiantest.css
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/content/bayesiantest.css	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,26 @@
+/*
+   Note: Copyied from downloads.css in winstripe.
+ */
+richlistbox {
+  border: 2px solid;
+  -moz-border-top-colors: ThreeDShadow ThreeDDarkShadow;
+  -moz-border-right-colors: ThreeDHighlight ThreeDLightShadow;
+  -moz-border-bottom-colors: ThreeDHighlight ThreeDLightShadow;
+  -moz-border-left-colors: ThreeDShadow ThreeDDarkShadow;
+}
+
+richlistitem {
+  padding-top: 6px;
+  padding-bottom: 6px;
+  -moz-padding-start: 7px;
+  -moz-padding-end: 7px;
+  min-height: 25px;
+  border-bottom: 1px dotted #C0C0C0;
+}
+
+.detail {
+  display: none;
+}
+richlistitem[selected="true"] > .detail {
+  display: -moz-box;
+}
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/content/bayesiantest.js
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/content/bayesiantest.js	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,282 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+var gTrainingManager = {
+  mQueCount : 0,
+  mProgressCount : 0,
+  mLastCache : [],
+
+  onProgress: function _bttd_onprogress_ (aTopic, aData) {
+    if (aTopic) {
+      /* update database label */
+      if (aData) {
+        var score = document.getElementById("urn:" + aTopic)
+                            .firstChild
+                            .firstChild
+                            .nextSibling
+                            .nextSibling;
+        score.value = this.formattedScore(aData);
+        this.mLastCache[aTopic] =  this.formattedScore(aData);
+      }
+      this.mProgressCount++;
+    }
+
+    /* update progressmeter */
+    document.getElementById("progress").value =
+      parseInt((100 * this.mProgressCount)/this.mQueCount + 5).toString();
+    if (this.mQueCount == this.mProgressCount) {
+      this.mQueCount = 0,
+      this.mProgressCount = 0,
+      setTimeout(gTrainingManager.resetProgress, 500);
+    }
+  },
+
+  resetProgress: function _bttd_resetprogress_() {
+    document.getElementById("progress").value = 0;
+  },
+
+  get mTestService() {
+    return Components.classes["@mozilla.org/extensions/bayesiantest/gr;1"]
+              .getService(Components.interfaces.mozIBayesianTestService);
+  },
+
+  get mTestUtils() {
+    return Components.classes["@mozilla.org/rdf/datasource;1?name=bayesiantest"]
+              .getService(Components.interfaces.mozIBayesianTestUtils);
+  },
+
+  get mStringBundle() {
+    var sbs = Components.classes["@mozilla.org/intl/stringbundle;1"]
+              .getService(Components.interfaces.nsIStringBundleService);
+    return sbs.createBundle("chrome://bayesiantest/locale/bayesiantest.properties");
+  },
+
+  get defaultScore() {
+    return this.mStringBundle.GetStringFromName("defaultScore");
+  },
+
+  formattedScore: function (aScore) {
+    return this.mStringBundle
+               .formatStringFromName("formattedScore", [aScore], 1);
+  },
+
+  train : function _bttd_train_(aEvent) {
+    aEvent.target.setAttribute("disabled", "true");
+    var text = document.getElementById("content-area").value;
+    var uri = document.getElementById("uri-area").value;
+    var root = aEvent.target.parentNode.parentNode;
+    var id = "" + root.getAttribute("id");
+    id = id.replace(/^urn:/, "");
+    if (gObserver.id)
+      id += gObserver.id;
+    var radiogroup = root.getElementsByTagName("radiogroup")[0];
+    var value = radiogroup.value;
+    value = value? parseInt(value) : 2;
+    radiogroup.selectedIndex = 2;
+    if (value >2)
+      return;
+    var score = root.firstChild.firstChild
+                    .nextSibling.nextSibling;
+    score.value = this.defaultScore;
+    this.mQueCount++;
+    this.mTestService.trainAsync(id, uri, text, (value == 0), gObserver);
+    this.onProgress(null, null);
+  },
+
+  radioSelect : function _bttd_radioselect_(aEvent, aEnabled) {
+    var button = aEvent.target.parentNode.nextSibling.nextSibling;
+    if (!aEnabled)
+      button.setAttribute("disabled", "true");
+    else if (button.hasAttribute("disabled"))
+      button.removeAttribute("disabled");
+  },
+
+  test : function _bttd_test_() {
+    var text = document.getElementById("content-area").value;
+    var uri = document.getElementById("uri-area").value;
+    var elements = document.getElementsByTagName("richlistitem");
+    var length = elements.length;
+
+    if (this.mQueCount == 0)
+      this.resetProgress();
+
+    for (var i = 0; i < length; i ++) {
+      var id = "" + elements[i].getAttribute("id");
+      id = id.replace(/^urn:/, "");
+      if (id && text) {
+        var score = elements[i].firstChild
+                               .firstChild
+                               .nextSibling
+                               .nextSibling;
+        if(this.mLastCache[id])
+          score.value = this.mLastCache[id];
+        else {
+          score.value = this.defaultScore;
+          this.mQueCount++;
+          if (gObserver.id)
+            id += gObserver.id;
+          this.mTestService.testAsync(id, uri, text, gObserver);
+        }
+      }
+    }
+  },
+
+  trainAll : function _bttd_trainall_() {
+    var text = document.getElementById("content-area").value;
+    var uri = document.getElementById("uri-area").value;
+    var elements = document.getElementsByTagName("richlistitem");
+    var length = elements.length;
+
+    if (this.mQueCount == 0)
+      this.resetProgress();
+
+    for (var i = 0; i < length; i ++) {
+      var id = "" + elements[i].getAttribute("id");
+      id = id.replace(/^urn:/, "");
+      if (id && text) {
+        if (gObserver.id)
+          id += gObserver.id;
+        var value = elements[i].getElementsByTagName("radiogroup")[0].value;
+        value = value? parseInt(value) : 2;
+        if (value < 2) {
+          var score = elements[i].firstChild
+                                 .firstChild
+                                 .nextSibling
+                                 .nextSibling;
+          score.value = this.defaultScore;
+          this.mQueCount++;
+          this.mTestService.trainAsync(id, uri, text, (value == 0), gObserver);
+        }
+      }
+    }
+  },
+
+  delete : function _bttd_delete_(aEvent) {
+    var element = aEvent.target.parentNode.parentNode;
+    var topic = element.firstChild.firstChild.value;
+    if (confirm(this.mStringBundle
+                    .formatStringFromName("deleteDialogText",
+                                          [topic], 1))) {
+      this.mTestUtils.deleteTopic(element.resource);
+      this.test();
+    }
+  },
+
+  add : function (aEvent) {
+    var topic = prompt(this.mStringBundle.GetStringFromName("addDialogText"),
+                       "", null, 0);
+    if(!topic)
+      return;
+    this.mTestUtils.createTopic(topic);
+    this.test();
+  },
+
+  flush: function () {
+    this.mTestUtils.flush();
+  }
+}
+
+function showAdvancedDialog(aEvent) {
+  var id = aEvent.target.parentNode.parentNode
+                 .getAttribute("id")
+                 .replace(/^urn:/, "");
+
+  openDialog("chrome://bayesiantest/content/bayesiantest-properties.xul",
+             "_blank", "chrome,dialog=no,all", id);
+}
+
+var gObserver = {
+  id: "",
+  observe: function(aSubject, aTopic, aData) {
+    var testee = aSubject.QueryInterface(Components.interfaces
+                                                   .mozIBayesianTestee);
+    if (!this.id || aSubject.testerID.match(this.id)) {
+      var testerID = testee.testerID.replace(this.id, "")
+      if (Components.interfaces.mozIBayesianTestee.MODE_CANCELED &
+          testee.mode)
+        gTrainingManager.onProgress(testerID, null);
+      else
+        gTrainingManager.onProgress(testerID,
+                                    (parseInt(testee.result*10000)).toString());
+    }
+  },
+
+  QueryInterface: function(iid) {
+    if (iid.equals(Components.interfaces.nsIObserver)
+     || iid.equals(Components.interfaces.nsISupports)) {
+      return this;
+    }
+    else {
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  }
+};
+
+function startup(aEvent) {
+  if (window.arguments) {
+    if (window.arguments[0])
+      document.getElementById("uri-area").value = window.arguments[0];
+    if (window.arguments[2]) {
+      document.getElementById("uri-area").readOnly = false;
+      document.getElementById("content-area").readOnly = false;
+      document.getElementById("content-area").hidden = false;
+    }
+  }
+
+  gObserver.id = "@" + (new Date()).getTime();
+
+  setTimeout(startup2, 100);
+}
+
+function shutdown(aEvent) {
+  var obs = Components.classes["@mozilla.org/observer-service;1"]
+                      .getService(Components.interfaces.nsIObserverService);
+  obs.removeObserver(gObserver, "moz-bayesiantest-service");
+  gTrainingManager.flush();
+}
+
+function startup2() {
+  if (window.arguments && window.arguments[1])
+    document.getElementById("content-area").value = window.arguments[1];
+  var obs = Components.classes["@mozilla.org/observer-service;1"]
+                      .getService(Components.interfaces.nsIObserverService);
+  obs.addObserver(gObserver, "moz-bayesiantest-service", false);
+  gTrainingManager.test();
+}
+
+function dispatchTestEvent() {
+  gTrainingManager.mLastCache =[];
+  gTrainingManager.test();
+}
+
+window.addEventListener("load", startup, false);
+window.addEventListener("unload", shutdown, false);
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/content/bayesiantest.xul
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/content/bayesiantest.xul	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,79 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+<?xml-stylesheet href="chrome://bayesiantest/content/bayesiantest.css" type="text/css"?>
+
+<!DOCTYPE window SYSTEM "chrome://bayesiantest/locale/">
+
+<window id="bayesiant-main-window"
+        title="&bayesiantest.window.title;"
+        orient="vertical"
+        xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        persist="width height">
+
+  <script type="application/x-javascript"
+          src="chrome://bayesiantest/content/bayesiantest.js"/>
+
+  <textbox id="uri-area" multiline="no" readonly="true"/>
+  <textbox id="content-area" multiline="true" rows="7" hidden="true"
+           readOnly="false"/>
+  <richlistbox id="topic-list2"
+               flex="1"
+               template="topic-template2"
+               datasources="rdf:bayesiantest"
+               ref="urn:mozilla/extensions/bayesiantest:root"/>
+  <hbox id="bottom-toolbar">
+    <button label="&bayesiantest.add.label;"
+            accesskey="&bayesiantest.add.accesskey;"
+            oncommand="gTrainingManager.add(event);"/>
+    <progressmeter id="progress" value="0" mode = "determined" flex="1"/>
+  </hbox>
+  <template id="topic-template2">
+    <rule>
+      <conditions>
+        <content uri="?start"/>
+        <member container="?start" child="?uri"/>
+        <triple subject="?uri"
+                predicate="http://www.mozilla.org/mozilla/extensions/bayesiantest/#topic"
+                object="?topic"/>
+      </conditions>
+      <action>
+        <richlistitem uri="?uri" label="?topic"
+                      orient="vertical">
+          <hbox>
+            <label value="&bayesiantest.topic.label;" class="header"/>
+            <spacer flex="1"/>
+            <label value="&bayesiantest.score.label;" />
+          </hbox>
+          <hbox class="detail" flex="1">
+            <radiogroup orient="horizontal">
+              <radio label="&bayesiantest.radio.positive.label;"
+                     oncommand="gTrainingManager.radioSelect(event, true)"
+                     value="0"/>
+              <radio label="&bayesiantest.radio.negative.label;"
+                     oncommand="gTrainingManager.radioSelect(event, true)"
+                     value="1"/>
+              <radio label="&bayesiantest.radio.skip.label;"
+                     oncommand="gTrainingManager.radioSelect(event, false)"
+                     selected="true" value="2"/>
+            </radiogroup>
+            <spacer flex="1"/>
+            <button label="&bayesiantest.train.label;"
+                    accesskey="&bayesiantest.train.accesskey;"
+                    disabled="true"
+                    oncommand="gTrainingManager.train(event);"/>
+          </hbox>
+          <hbox class="detail" flex="1">
+            <button label="&bayesiantest.properties.label;"
+                    oncommand="showAdvancedDialog(event);"/>
+                    <!-- accesskey="&bayesiantest.properties.accesskey;" -->
+            <spacer flex="1"/>
+            <button label="&bayesiantest.delete.label;"
+                    accesskey="&bayesiantest.delete.accesskey;"
+                    oncommand="gTrainingManager.delete(event);"/>
+          </hbox>
+        </richlistitem>
+      </action>
+    </rule>
+  </template>
+</window>
diff -up8rN /dev/null mozilla/extensions/bayesiantest/resources/jar.mn
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/resources/jar.mn	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,9 @@
+bayesiantest.jar:
+% content bayesiantest %content/bayesiantest/ xpcnativewrappers=yes
+  content/bayesiantest/bayesiantest-dump.xul (content/bayesiantest-dump.xul)
+  content/bayesiantest/bayesiantest-dump.js (content/bayesiantest-dump.js)
+  content/bayesiantest/bayesiantest-properties.xul (content/bayesiantest-properties.xul)
+  content/bayesiantest/bayesiantest-properties.js (content/bayesiantest-properties.js)
+  content/bayesiantest/bayesiantest.xul       (content/bayesiantest.xul)
+  content/bayesiantest/bayesiantest.js       (content/bayesiantest.js)
+  content/bayesiantest/bayesiantest.css       (content/bayesiantest.css)
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/Makefile.in
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/Makefile.in	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,77 @@
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is mozilla.org code.
+#
+# Contributor(s):
+#  O. Atushi <torisugari@gmail.com>
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+DEPTH            = ../../..
+topsrcdir        = @top_srcdir@
+srcdir           = @srcdir@
+VPATH            = @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= bayesiantest
+LIBRARY_NAME    = bayesiantest
+SHORT_LIBNAME  = bayestes
+EXPORT_LIBRARY  = 1
+IS_COMPONENT    = 1
+MODULE_NAME     = mozBayesianTestModule
+GRE_MODULE      = 1
+
+# You can commentout this flag.
+MOZILLA_INTERNAL_API = 1
+
+REQUIRES        = xpcom     \
+		  string    \
+		  storage   \
+		  $(NULL)
+
+CPPSRCS         = mozBayesianTester.cpp        \
+		  mozBayesianTestService.cpp   \
+		  mozBayesianTestModule.cpp    \
+		  mozSimpleTokenizer.cpp       \
+		  mozPlaintextTokenizerJA.cpp  \
+		  $(NULL)
+
+ifdef MOZILLA_INTERNAL_API
+EXTRA_DSO_LDOPTS = \
+		$(MOZ_COMPONENT_LIBS) \
+		$(LIBS_DIR) \
+		$(NULL)
+else
+EXTRA_DSO_LDOPTS = \
+		$(XPCOM_GLUE_LDOPTS) \
+		$(NSPR_LIBS) \
+		$(NULL)
+endif
+
+include $(topsrcdir)/config/rules.mk
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozBayesianTestModule.cpp
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozBayesianTestModule.cpp	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+#include "nsICategoryManager.h"
+#include "nsIGenericFactory.h"
+
+#include "mozPlaintextTokenizer.h"
+#include "mozBayesianTestService.h"
+
+NS_GENERIC_FACTORY_CONSTRUCTOR(mozSimpleTokenizer)
+NS_GENERIC_FACTORY_CONSTRUCTOR(mozPlaintextTokenizerJA)
+NS_GENERIC_FACTORY_CONSTRUCTOR(mozBayesianTestService)
+
+static const nsModuleComponentInfo components[] = {
+
+  { "Simple Plaintext Tokenizer",
+    MOZ_SIMPLE_TOKENIZER_CID,
+    MOZ_SIMPLE_TOKENIZER_CONTRACTID,
+    mozSimpleTokenizerConstructor },
+
+  { "Plaintext Tokenizer/Japanese",
+    MOZ_PLAINTEXT_TOKENIZER_JA_CID,
+    MOZ_PLAINTEXT_TOKENIZER_JA_CONTRACTID,
+    mozPlaintextTokenizerJAConstructor },
+
+  { "Bayesian Test Service (GR)",
+    MOZ_BAYESIANTEST_SERVICE_CID,
+    MOZ_BAYESIANTEST_SERVICE_CONTRACTID,
+    mozBayesianTestServiceConstructor }
+};
+
+NS_IMPL_NSGETMODULE(mozBayesianTestModule, components)
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozBayesianTestService.cpp
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozBayesianTestService.cpp	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,369 @@
+/* mozBayesianTestService */
+#ifdef MOZILLA_INTERNAL_API
+#include "nsString.h"
+#else
+#include "nsStringAPI.h"
+#include <stdio.h>
+#endif
+
+#include "mozBayesianTester.h"
+#include "mozBayesianTestService.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIProxyObjectManager.h"
+#include "nsAutoLock.h"
+
+#define BAYESIAN_DATABASE_DIRECTORY "bayesian"
+
+inline nsresult MOZ_NEW_BAYESIANTESTER(nsIFile* aFile,
+                                       mozIBayesianTester** _retval) {
+
+  NS_ENSURE_ARG_POINTER(aFile);
+
+  mozBayesianTester* tester = new mozBayesianTester();
+  NS_ENSURE_TRUE(tester, NS_ERROR_OUT_OF_MEMORY);
+  NS_ADDREF(tester);
+
+  nsresult rv = tester->Init(aFile);
+  if (NS_FAILED(rv)) {
+    NS_RELEASE(tester);
+    return rv;
+  }
+
+  *_retval = NS_STATIC_CAST(mozIBayesianTester*, tester);
+  return NS_OK;
+}
+
+inline nsresult MOZ_NEW_BAYESIANTESTER(const nsACString& aTesterID,
+                                       mozIBayesianTester** _retval) {
+  if (aTesterID.IsEmpty())
+    return NS_ERROR_INVALID_ARG;
+
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = NS_GetSpecialDirectory(NS_APP_PREFS_50_DIR,
+                                       getter_AddRefs(file));
+
+  rv = file->Append(NS_LITERAL_STRING(BAYESIAN_DATABASE_DIRECTORY));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  PRBool exists;
+  rv = file->Exists(&exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!exists) {
+    rv = file->Create(nsIFile::DIRECTORY_TYPE, 0700);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCAutoString leafName;
+  leafName.Assign(aTesterID);
+  leafName.Truncate(38);
+  leafName.AppendLiteral(".sqlite");
+
+  rv = file->AppendNative(leafName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return MOZ_NEW_BAYESIANTESTER(file, _retval);
+}
+
+inline nsresult MOZ_NEW_BAYESIANTESTEE(PRUint16 aMode,
+                                       const nsACString& aTesterID,
+                                       const nsACString& aDocumentID,
+                                       const nsAString& aDocumentBody,
+                                       double aResult,
+                                       mozIBayesianTestee** aObject) {
+  mozBayesianTestee* testee = new mozBayesianTestee(aMode,
+                                                    aTesterID,
+                                                    aDocumentID,
+                                                    aDocumentBody,
+                                                    aResult);
+  NS_ENSURE_TRUE(testee, NS_ERROR_OUT_OF_MEMORY);
+  NS_ADDREF(*aObject = testee);
+  return NS_OK;
+}
+
+/* Bayesian Testee */
+
+NS_IMPL_THREADSAFE_ISUPPORTS1(mozBayesianTestee, mozIBayesianTestee)
+
+mozBayesianTestee::mozBayesianTestee(PRUint16 aMode,
+                                     const nsACString& aTesterID,
+                                     const nsACString& aDocumentID,
+                                     const nsAString& aDocumentBody,
+                                     double aResult) {
+  mMode = aMode;
+  mDocumentID = aDocumentID;
+  mTesterID = aTesterID;
+  mDocumentBody = aDocumentBody;
+  mResult = aResult;
+}
+
+mozBayesianTestee::~mozBayesianTestee() {
+}
+
+NS_IMETHODIMP mozBayesianTestee::GetMode(PRUint16 *aMode) {
+  NS_ENSURE_ARG_POINTER(aMode);
+  *aMode = mMode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTestee::SetMode(PRUint16 aMode) {
+  mMode = aMode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozBayesianTestee::GetTesterID(nsACString & aTesterID) {
+  aTesterID = mTesterID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozBayesianTestee::SetTesterID(const nsACString & aTesterID) {
+  mTesterID = aTesterID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozBayesianTestee::GetDocumentID(nsACString & aDocumentID) {
+  aDocumentID = mDocumentID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTestee::SetDocumentID(const nsACString & aDocumentID) {
+  mDocumentID = aDocumentID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTestee::GetDocumentBody(nsAString & aDocumentBody) {
+  aDocumentBody = mDocumentBody;
+  return NS_OK;
+}
+NS_IMETHODIMP
+mozBayesianTestee::SetDocumentBody(const nsAString & aDocumentBody) {
+  mDocumentBody = aDocumentBody;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozBayesianTestee::GetResult(double *aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = mResult;
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozBayesianTestee::SetResult(double aResult) {
+  mResult = aResult;
+  return NS_OK;
+}
+
+
+NS_IMPL_THREADSAFE_ISUPPORTS2(mozBayesianTestService,
+                              nsIObserver,
+                              mozIBayesianTestService)
+
+mozBayesianTestService::mozBayesianTestService():mCurrentTestee(nsnull) {
+  mTesteeFolder.Clear();
+  mLock = PR_NewLock();
+}
+
+mozBayesianTestService::~mozBayesianTestService() {
+  PR_DestroyLock(mLock);
+}
+
+NS_IMETHODIMP
+mozBayesianTestService::CreateTester(nsIFile *aDBFile,
+                                     mozIBayesianTester **_retval) {
+  return MOZ_NEW_BAYESIANTESTER(aDBFile, _retval);
+}
+
+NS_IMETHODIMP
+mozBayesianTestService::CreateTesterFromAlias(const nsACString & aAlias,
+                                              mozIBayesianTester **_retval) {
+  // Formal aAlias is a UUID,
+  // such as "{0000000-0000-0000-0000-000000000000}"
+  return MOZ_NEW_BAYESIANTESTER(aAlias, _retval);
+}
+
+#include "nsThreadUtils.h"
+
+class BayesianTestEvent : public nsRunnable {
+public:
+  BayesianTestEvent(mozIBayesianTestee* testee,
+                    nsIObserver* observer);
+  NS_IMETHOD Run() {
+    nsresult rv;
+
+    PRUint16 mode;
+    rv = mTestee->GetMode(&mode);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCAutoString documentID, testerID;
+    rv = mTestee->GetDocumentID(documentID);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = mTestee->GetTesterID(testerID);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString documentBody;
+    rv = mTestee->GetDocumentBody(documentBody);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<mozIBayesianTester> tester;
+    rv = MOZ_NEW_BAYESIANTESTER(testerID, getter_AddRefs(tester));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (mode & mozIBayesianTestee::MODE_TRAIN) {
+      PRBool isPositive = (mode & mozIBayesianTestee::VALUE_POSITIVE);
+      rv = tester->Train(documentID, documentBody, isPositive);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    if ((mode & mozIBayesianTestee::MODE_TEST) &&
+        !(mode & mozIBayesianTestee::MODE_CANCELED)) {
+      double result;
+      rv = tester->Test(documentBody, &result);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = mTestee->SetResult(result);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    return mObserver->Observe(mTestee, MOZ_BAYESIAN_OBSERVERTOPIC, nsnull);
+
+  }
+private:
+  nsCOMPtr<nsIObserver> mObserver;
+  nsCOMPtr<mozIBayesianTestee> mTestee;
+};
+
+BayesianTestEvent::BayesianTestEvent(mozIBayesianTestee* aTestee,
+                                     nsIObserver* aObserver) {
+  mObserver = aObserver;
+  mTestee = aTestee;
+}
+
+nsresult
+mozBayesianTestService::DispatchBayesianTestEvent(mozIBayesianTestee* aTestee) {
+#ifdef MOZILLA_INTERNAL_API
+  nsAutoLock lock(mLock);
+#endif
+  nsresult rv;
+  if (!mThread) {
+    nsCOMPtr<nsIThreadManager>
+      tm(do_GetService("@mozilla.org/thread-manager;1", &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = tm->NewThread(0, getter_AddRefs(mThread));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIProxyObjectManager>
+    pom(do_GetService("@mozilla.org/xpcomproxy;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIBayesianTestee> proxyTestee;
+  rv = pom->GetProxyForObject(NS_PROXY_TO_CURRENT_THREAD,
+                              NS_GET_IID(mozIBayesianTestee),
+                              aTestee,
+                              nsIProxyObjectManager::INVOKE_SYNC |
+                              nsIProxyObjectManager::FORCE_PROXY_CREATION,
+                              getter_AddRefs(proxyTestee));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsIObserver* observer = NS_STATIC_CAST(nsIObserver*, this);
+
+  nsCOMPtr<nsIObserver> proxyObserver;
+  rv = pom->GetProxyForObject(NS_PROXY_TO_CURRENT_THREAD,
+                              NS_GET_IID(nsIObserver),
+                              observer,
+                              nsIProxyObjectManager::INVOKE_SYNC |
+                              nsIProxyObjectManager::FORCE_PROXY_CREATION,
+                              getter_AddRefs(proxyObserver));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  BayesianTestEvent* event =
+    new BayesianTestEvent(proxyTestee, proxyObserver);
+  NS_ENSURE_TRUE(event, NS_ERROR_OUT_OF_MEMORY);
+
+  return mThread->Dispatch(event, nsIThread::DISPATCH_NORMAL);
+}
+
+nsresult
+mozBayesianTestService::FileBayesianTestee(PRUint16 aMode,
+                                           const nsACString& aTesterID,
+                                           const nsACString& aDocumentID,
+                                           const nsAString & aDocumentBody) {
+
+  nsCOMPtr<mozIBayesianTestee> testee;
+  nsresult rv = MOZ_NEW_BAYESIANTESTEE(aMode, aTesterID,
+                                       aDocumentID, aDocumentBody,
+                                       GR_DEFAULT_ASSUMED_PROBABILITY,
+                                       getter_AddRefs(testee));
+  if (mCurrentTestee) {
+    for (PRInt32 i = 0; i < mTesteeFolder.Count(); i++) {
+      mozIBayesianTestee* oldTestee = mTesteeFolder.ObjectAt(i);
+
+      nsCAutoString oldTesterID;
+      rv = oldTestee->GetTesterID(oldTesterID);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      PRUint16 oldMode;
+      rv = oldTestee->GetMode(&oldMode);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (oldTesterID.Equals(aTesterID)) {
+        rv = oldTestee->SetMode(oldMode | mozIBayesianTestee::MODE_CANCELED);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+
+    mTesteeFolder.AppendObject(testee);
+  }
+  else {
+    mCurrentTestee = testee;
+    rv = DispatchBayesianTestEvent(testee);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTestService::Observe(nsISupports* aSubject,
+                                const char* aTopic,
+                                const PRUnichar* aData) {
+   nsresult rv;
+   if (mTesteeFolder.Count() > 0) {
+     mCurrentTestee = mTesteeFolder.ObjectAt(0);
+     mTesteeFolder.RemoveObjectAt(0);
+     rv = DispatchBayesianTestEvent(mCurrentTestee);
+     NS_ENSURE_SUCCESS(rv, rv);
+   }
+   else
+     mCurrentTestee = nsnull;
+
+   nsCOMPtr<nsIObserverService>
+     observerService(do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv));
+   NS_ENSURE_SUCCESS(rv, rv);
+   return observerService->NotifyObservers(aSubject, aTopic, aData);
+}
+
+NS_IMETHODIMP
+mozBayesianTestService::TestAsync(const nsACString& aAlias,
+                                  const nsACString& aURISpec,
+                                  const nsAString & aDocument) {
+  PRUint16 flag = mozIBayesianTestee::MODE_TEST;
+  return FileBayesianTestee(flag, aAlias, aURISpec, aDocument);
+}
+
+NS_IMETHODIMP
+mozBayesianTestService::TrainAsync(const nsACString& aAlias,
+                                   const nsACString& aURISpec,
+                                   const nsAString & aDocument,
+                                   PRBool aIsPositive) {
+  PRUint16 flag = mozIBayesianTestee::MODE_TEST |
+                 mozIBayesianTestee::MODE_TRAIN;
+  if (aIsPositive)
+    flag |= mozIBayesianTestee::VALUE_POSITIVE;
+  return FileBayesianTestee(flag, aAlias, aURISpec, aDocument);
+}
+
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozBayesianTestService.h
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozBayesianTestService.h	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+#ifndef __MOZ_BAYESIANTEST_SERVICE__
+#define __MOZ_BAYESIANTEST_SERVICE__
+
+#include "nsCOMPtr.h"
+#include "nsServiceManagerUtils.h"
+
+#include "mozIBayesianTester.h"
+#include "nsIThread.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsCOMArray.h"
+#include "prlock.h"
+
+// {898F34CD-1C46-4a5e-B828-8D57919E7AE2}
+#define MOZ_BAYESIANTEST_SERVICE_CID \
+{0x898f34cd, 0x1c46, 0x4a5e, {0xb8, 0x28, 0x8d, 0x57, 0x91, 0x9e, 0x7a, 0xe2}}
+#define MOZ_BAYESIANTEST_SERVICE_CONTRACTID \
+"@mozilla.org/extensions/bayesiantest/gr;1"
+/* gr is Garry Robinson model */
+
+#define MOZ_BAYESIAN_OBSERVERTOPIC "moz-bayesiantest-service"
+
+class mozBayesianTestService : public mozIBayesianTestService,
+                               public nsIObserver {
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+  NS_DECL_MOZIBAYESIANTESTSERVICE
+
+  mozBayesianTestService();
+
+private:
+  ~mozBayesianTestService();
+  nsCOMPtr<nsIThread> mThread;
+  nsresult FileBayesianTestee(PRUint16 aMode,
+                              const nsACString& aAlias,
+                              const nsACString& aURISpec,
+                              const nsAString & aDocument);
+
+  nsresult DispatchBayesianTestEvent(mozIBayesianTestee* aTestee);
+
+  PRLock *mLock;
+  nsCOMArray<mozIBayesianTestee> mTesteeFolder;
+  nsCOMPtr<mozIBayesianTestee> mCurrentTestee;
+};
+
+class mozBayesianTestee : public mozIBayesianTestee {
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_MOZIBAYESIANTESTEE
+
+  mozBayesianTestee(PRUint16 aMode,
+                    const nsACString& aTesterID,
+                    const nsACString& aDocumentID,
+                    const nsAString& aDocumentBody,
+                    double aResult);
+private:
+  ~mozBayesianTestee();
+  PRUint16 mMode;
+  nsCString mTesterID;
+  nsCString mDocumentID;
+  nsString mDocumentBody;
+  double mResult;
+};
+#endif
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozBayesianTester.cpp
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozBayesianTester.cpp	2006-12-03 20:02:43.000000000 +0900
@@ -0,0 +1,802 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   Patrick C. Beard <beard@netscape.com>
+ *   Seth Spitzer <sspitzer@netscape.com>
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include "mozBayesianTester.h"
+#include "mozStorageCID.h"
+#include "mozIStorageService.h"
+#include "mozStorageHelper.h"
+#include "nsServiceManagerUtils.h"
+#include "mozPlaintextTokenizer.h"
+
+#define MAX_TOKEN_LENGTH 127
+#define MAX_URI_LENGTH 254
+
+#ifdef DEBUG
+// #define DEBUG_BAYESIAN_TEST
+#define DEBUG_BAYESIAN_PERFORMANCE
+#endif
+
+#ifndef MOZ_BAYESE_TOKENIZE_JAPANESE
+#define MOZ_BAYESE_TOKENIZE_JAPANESE 1
+#endif
+
+#ifndef MOZILLA_INTERNAL_API
+#include <stdio.h>
+#include "nsComponentManagerUtils.h"
+#endif
+
+#include "nsIncompleteGamma.h"
+
+#ifndef M_LN2
+#define M_LN2 0.69314718055994530942
+#endif
+
+#ifndef M_E
+#define M_E   2.7182818284590452354
+#endif
+
+// Chi square functions are implemented by an incomplete gamma function.
+// Note that chi2P's callers multiply the arguments by 2 but chi2P
+// divides them by 2 again. Inlining chi2P gives the compiler a
+// chance to notice this.
+
+// Both chi2P and nsIncompleteGammaP set *error negative on domain
+// errors and nsIncompleteGammaP sets it posivive on internal errors.
+// This may be useful but the chi2P callers treat any error as fatal.
+
+// Note that converting unsigned ints to floating point can be slow on
+// some platforms (like Intel) so use signed quantities for the numeric
+// routines.
+static inline double
+chi2P (double chi2, double nu, PRInt32 *error) {
+  // domain checks; set error and return a dummy value
+  if (chi2 < 0.0 || nu <= 0.0) {
+    *error = -1;
+    return 0.0;
+  }
+  // reversing the arguments is intentional
+  return nsIncompleteGammaP (nu/2.0, chi2/2.0, error);
+}
+
+NS_IMPL_ISUPPORTS1(mozBayesianTester, mozIBayesianTester)
+
+mozBayesianTester::mozBayesianTester()
+  :mTokenizer(nsnull),
+   mPositiveDocuments(0),
+   mNegativeDocuments(0),
+   mStrength(GR_DEFAULT_STRENGTH),
+   mAssumedProbability(GR_DEFAULT_ASSUMED_PROBABILITY){
+}
+
+mozBayesianTester::~mozBayesianTester() {
+}
+
+nsresult mozBayesianTester::Init(nsIFile *aDBFile) {
+  NS_ENSURE_ARG_POINTER(aDBFile);
+
+  nsresult rv;
+  nsCOMPtr<mozIStorageService> storageService;
+  storageService = do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = storageService->OpenDatabase(aDBFile, getter_AddRefs(mStorage));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = InitInternal();
+
+  mStorage->CommitTransaction();
+
+  return rv;
+}
+
+nsresult mozBayesianTester::InitInternal() {
+  // positive tokens counter
+  nsresult rv;
+  rv = EnsureTableExists("positiveTokens", "token char(255), count INTEGER");
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // negative tokens counter
+  rv = EnsureTableExists("negativeTokens", "token char(255), count INTEGER");
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // URIs of negative documents
+  rv = EnsureTableExists("positiveDocuments", "uri char(255)");
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // URIs of positive documents
+  rv = EnsureTableExists("negativeDocuments", "uri char(255)");
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // init SQL statements
+  /*XXX Not too sure, but maybe we should use
+        views instead of simple statements...? */
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("SELECT count "
+                                                    "FROM positiveTokens "
+                                                    "WHERE token = ?1;"),
+                                 getter_AddRefs(mPositiveTokenCounter));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("SELECT count "
+                                                    "FROM negativeTokens "
+                                                    "WHERE token = ?1;"),
+                                 getter_AddRefs(mNegativeTokenCounter));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("INSERT "
+                                                    "INTO positiveDocuments "
+                                                    "(uri) VALUES(?1);"),
+                                 getter_AddRefs(mAppendPositiveURI));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("INSERT "
+                                                    "INTO negativeDocuments "
+                                                    "(uri) VALUES(?1);"),
+                                 getter_AddRefs(mAppendNegativeURI));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("INSERT "
+                                                    "INTO positiveTokens "
+                                                    "(token, count) "
+                                                    "VALUES(?1, 1);"),
+                                 getter_AddRefs(mInsertPositiveToken));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("INSERT "
+                                                    "INTO negativeTokens "
+                                                    "(token, count) "
+                                                    "VALUES(?1, 1);"),
+                                 getter_AddRefs(mInsertNegativeToken));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("UPDATE positiveTokens "
+                                                    "SET count = ?1 "
+                                                    "WHERE token = ?2;"),
+                                 getter_AddRefs(mUpdatePositiveToken));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mStorage->CreateStatement(NS_LITERAL_CSTRING("UPDATE negativeTokens "
+                                                    "SET count = ?1 "
+                                                    "WHERE token = ?2;"),
+                                 getter_AddRefs(mUpdateNegativeToken));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // init members
+  rv = CopyRowCounts("positiveDocuments", &mPositiveDocuments);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = CopyRowCounts("negativeDocuments", &mNegativeDocuments);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+mozBayesianTester::EnsureTokenizerIsReady() {
+  if (mTokenizer)
+    return NS_OK;
+
+  nsresult rv;
+#if MOZ_BAYESE_TOKENIZE_JAPANESE
+  mTokenizer = do_CreateInstance(MOZ_PLAINTEXT_TOKENIZER_JA_CONTRACTID, &rv);
+#else
+  mTokenizer = do_CreateInstance(MOZ_SIMPLE_TOKENIZER_CONTRACTID, &rv);
+#endif
+  return rv;
+}
+
+nsresult
+mozBayesianTester::CopyRowCounts(const char* aTableName, PRInt32* aResult) {
+  nsCAutoString str("SELECT COUNT(*) FROM ");
+  str.Append(aTableName);
+
+  nsCOMPtr<mozIStorageStatement> statement;
+  nsresult rv = mStorage->CreateStatement(str, getter_AddRefs(statement));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  PRBool hasData;
+  rv = statement->ExecuteStep(&hasData);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!hasData) {
+    *aResult = 0;
+    return NS_OK;
+  }
+
+  return statement->GetInt32(0, aResult);
+}
+
+nsresult
+mozBayesianTester::EnsureTableExists(const char *aTableName,
+                                 const char *aTableScheme) {
+  PRBool exists;
+  nsresult rv = mStorage->TableExists(nsDependentCString(aTableName), &exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!exists)
+    rv = mStorage->CreateTable(aTableName, aTableScheme);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+mozBayesianTester::Test(const nsAString & aDocument, double *_retval) {
+#ifdef DEBUG_BAYESIAN_PERFORMANCE
+  PRTime start = PR_Now();
+#endif
+
+  if(!mStorage)
+    return NS_ERROR_NOT_INITIALIZED;
+
+  if ((mAssumedProbability <= 0) ||
+      (1 <= mAssumedProbability) ||
+      mStrength < 0)
+    return NS_ERROR_FAILURE;
+
+  PRUint32 tokenCount = 0;
+
+  // use a default tokenizer unless user specified one.
+  nsresult rv = EnsureTokenizerIsReady();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mTokenizer->Initialize(aDocument, 400);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifdef DEBUG_BAYESIAN_PERFORMANCE
+  PRTime middle = PR_Now();
+  PRUint64 span64;
+  LL_SUB (span64, middle, start);
+  PRUint32 span32;
+  LL_L2UI(span32, span64);
+  double sec = span32/1000000.0;
+  printf("mozBayesianTester::Test tokenize = %u microsec = %f sec\n",
+         span32, sec);
+#endif
+
+  nsCAutoString token, oldToken("");
+  PRBool hasMore;
+
+  /*
+     according to http://developer.mozilla.org/en/docs/Storage:Performance
+     we need transaction handlings even when read-only
+   */
+  rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  double f = 0.5;
+  double H = 1.0, S = 1.0;
+  PRInt32 Hexp = 0, Sexp = 0, e;
+
+  while (1) {
+
+    rv = mTokenizer->HasMore(&hasMore);
+
+    if (NS_FAILED(rv)) {
+      mStorage->CommitTransaction();
+      return rv;
+    }
+
+    if (!hasMore)
+      break;
+
+    rv = mTokenizer->GetNext(token);
+    if (NS_FAILED(rv)) {
+      mStorage->CommitTransaction();
+      return rv;
+    }
+
+    if (token.IsEmpty() ||
+        oldToken.Equals(token) ||          //skip dup
+        token.Length() > MAX_TOKEN_LENGTH)
+      continue;
+
+    tokenCount++;
+
+    f = F(token.get());
+
+    S *= (1.0 - f);
+    H *= f;
+    if (S < 1e-200) {
+      S = frexp(S, &e);
+      Sexp += e;
+    }
+
+    if (H < 1e-200) {
+      H = frexp(H, &e);
+      Hexp += e;
+    }
+
+    oldToken.Assign(token);
+  }
+
+  rv = mStorage->CommitTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  S = log(S) + Sexp * M_LN2;
+  H = log(H) + Hexp * M_LN2;
+
+  if (tokenCount > 0) {
+    PRInt32 chi_error;
+    S = chi2P(-2.0 * S, 2.0 * tokenCount, &chi_error);
+
+    if (!chi_error)
+      H = chi2P(-2.0 * H, 2.0 * tokenCount, &chi_error);
+      // if any error toss the entire calculation
+      if (!chi_error)
+        *_retval = (S-H +1.0) / 2.0;
+      else
+        *_retval = 0.5;
+    }
+    else
+      *_retval = 0.5;
+
+#ifdef DEBUG_BAYESIAN_PERFORMANCE
+  PRTime end = PR_Now();
+  LL_SUB (span64, end, middle);
+  LL_L2UI(span32, span64);
+  sec = span32/1000000.0;
+  printf("mozBayesianTester::Test calculation = %u microsec = %f sec\n",
+         span32, sec);
+#endif
+
+  return NS_OK;
+}
+
+double mozBayesianTester::F(const char* aToken) {
+  /*
+    This method will be called hundreds times per 1 document.
+    So we should optimize calcs/algs as much as possible.
+   */
+  PRInt32 positiveCounts = 0, negativeCounts =0, n;
+  double p;
+
+  /* Note that database access is twice per a token. Too heavy? */
+  nsresult rv = CopyPositiveCounts(aToken, &positiveCounts);
+  rv = CopyNegativeCounts(aToken, &negativeCounts);
+#ifdef DEBUG_BAYESIAN_TEST
+  printf("pdocuments:%d ndocuments:%d ",
+         mPositiveDocuments, mNegativeDocuments);
+  printf("ptokens:%d ntokens:%d ", positiveCounts, negativeCounts);
+#endif
+
+  if ((mNegativeDocuments*positiveCounts + negativeCounts*mPositiveDocuments)
+        == 0)
+    return mAssumedProbability;   /* Unknown token */
+  else
+    p = (positiveCounts*mNegativeDocuments) * 1.0 /
+        (positiveCounts*mNegativeDocuments + negativeCounts*mPositiveDocuments);
+#ifdef DEBUG_BAYESIAN_TEST
+  printf("p:%e\n", p);
+#endif
+  n = positiveCounts + negativeCounts;
+  return (mStrength * mAssumedProbability + n * p) / (mStrength + n);
+}
+
+nsresult
+mozBayesianTester::CopyPositiveCounts(const char* aToken, PRInt32* aResult) {
+  mozStorageStatementScoper scoper(mPositiveTokenCounter);
+  nsresult rv = mPositiveTokenCounter->
+                  BindUTF8StringParameter(0, nsDependentCString(aToken));
+  PRBool hasData;
+  rv = mPositiveTokenCounter->ExecuteStep(&hasData);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!hasData) {
+    *aResult = 0;
+
+    return NS_OK;
+  }
+
+  return mPositiveTokenCounter->GetInt32(0, aResult);
+}
+
+nsresult
+mozBayesianTester::CopyNegativeCounts(const char* aToken, PRInt32* aResult) {
+  mozStorageStatementScoper scoper(mNegativeTokenCounter);
+  nsresult rv = mNegativeTokenCounter->
+                  BindUTF8StringParameter(0, nsDependentCString(aToken));
+
+  PRBool hasData;
+  rv = mNegativeTokenCounter->ExecuteStep(&hasData);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!hasData) {
+    *aResult = 0;
+    return NS_OK;
+  }
+
+  return mNegativeTokenCounter->GetInt32(0, aResult);
+}
+
+nsresult
+mozBayesianTester::AppendURI(const nsACString& aURISpec, PRBool aIsPositive) {
+  if (aURISpec.IsEmpty() || aURISpec.Length() > MAX_URI_LENGTH)
+    return NS_ERROR_FAILURE;
+  mozIStorageStatement* statement = aIsPositive? mAppendPositiveURI:
+                                                 mAppendNegativeURI;
+
+  mozStorageStatementScoper scoper(statement);
+  nsresult rv = statement->BindUTF8StringParameter(0, aURISpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return statement->Execute();
+}
+
+nsresult
+mozBayesianTester::InsertToken(const nsACString& aToken, PRBool aIsPositive){
+  mozIStorageStatement* statement = aIsPositive? mInsertPositiveToken:
+                                                 mInsertNegativeToken;
+
+  mozStorageStatementScoper scoper(statement);
+
+  nsresult rv = statement->BindUTF8StringParameter(0, aToken);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return statement->Execute();
+}
+
+nsresult
+mozBayesianTester::UpdateToken(const nsACString& aToken,
+                           PRBool aIsPositive,
+                           PRInt32 aNewCount) {
+  mozIStorageStatement* statement = aIsPositive? mUpdatePositiveToken:
+                                                 mUpdateNegativeToken;
+  mozStorageStatementScoper scoper(statement);
+
+  nsresult rv = statement->BindInt32Parameter(0, aNewCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = statement->BindUTF8StringParameter(1, aToken);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return statement->Execute();
+}
+
+NS_IMETHODIMP
+mozBayesianTester::Train(const nsACString& aURISpec,
+                         const nsAString & aDocument,
+                         PRBool aIsPositive) {
+#ifdef DEBUG_BAYESIAN_PERFORMANCE
+  PRTime start = PR_Now();
+#endif
+
+  nsresult rv = EnsureTokenizerIsReady();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mTokenizer->Initialize(aDocument, 0);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCAutoString token, oldToken("");
+
+  rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv =AppendURI(aURISpec, aIsPositive);
+  if (NS_FAILED(rv)) {
+    mStorage->CommitTransaction();
+    return rv;
+  }
+
+  PRInt32 count = 0;
+
+  PRBool hasMore;
+  while (NS_SUCCEEDED(mTokenizer->HasMore(&hasMore)) && hasMore) {
+    rv = mTokenizer->GetNext(token);
+
+    if (NS_FAILED(rv)) {
+      mStorage->CommitTransaction();
+      return rv;
+    }
+
+    if (token.IsEmpty() ||
+        oldToken.Equals(token) ||          //skip dup
+        token.Length() > MAX_TOKEN_LENGTH)
+      continue;
+
+    if (aIsPositive)
+      CopyPositiveCounts(token.get(), &count);
+    else
+      CopyNegativeCounts(token.get(), &count);
+
+    if (count == 0)
+      InsertToken(token, aIsPositive);
+    else {
+      count++;
+      UpdateToken(token, aIsPositive, count);
+    }
+
+    oldToken.Assign(token);
+  }
+
+  rv = mStorage->CommitTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifdef DEBUG_BAYESIAN_PERFORMANCE
+  PRTime end = PR_Now();
+  PRUint64 span64;
+  LL_SUB (span64, end, start);
+  PRUint32 span32;
+  LL_L2UI(span32, span64);
+  double sec = span32/1000000.0;
+  printf("mozBayesianTester::Train span = %u microsec = %f sec\n",
+         span32, sec);
+#endif
+
+  rv = CopyRowCounts("positiveDocuments", &mPositiveDocuments);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return CopyRowCounts("negativeDocuments", &mNegativeDocuments);
+}
+
+NS_IMETHODIMP mozBayesianTester::GetDatabase(nsIFile * *aDatabase) {
+  NS_ENSURE_TRUE(mStorage, NS_ERROR_NOT_INITIALIZED);
+  return mStorage->GetDatabaseFile(aDatabase);
+}
+
+NS_IMETHODIMP mozBayesianTester::GetNegativeTokens(nsACString& aResult) {
+#ifdef MOZILLA_INTERANL_API
+  aResult.Truncate(0);
+#else
+  aResult.Truncate();
+#endif
+  PRBool hasData;
+  nsCAutoString row, str, number;
+
+  nsresult rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIStorageStatement> statement;
+
+  mStorage->CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM negativeTokens"),
+                            getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    row.Assign(statement->AsSharedUTF8String(0,nsnull));
+    row.AppendLiteral("\t\t");
+    row.AppendInt(statement->AsInt32(1));
+    row.AppendLiteral("\n");
+    aResult.Append(row);
+  }
+  return mStorage->CommitTransaction();
+}
+
+NS_IMETHODIMP mozBayesianTester::GetPositiveTokens(nsACString& aResult) {
+#ifdef MOZILLA_INTERANL_API
+  aResult.Truncate(0);
+#else
+  aResult.Truncate();
+#endif
+  PRBool hasData;
+  nsCAutoString row, str, number;
+
+  nsresult rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIStorageStatement> statement;
+
+  mStorage->CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM positiveTokens"),
+                            getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    row.Assign(statement->AsSharedUTF8String(0,nsnull));
+    row.AppendLiteral("\t\t");
+    row.AppendInt(statement->AsInt32(1));
+    row.AppendLiteral("\n");
+    aResult.Append(row);
+  }
+  return mStorage->CommitTransaction();
+}
+
+NS_IMETHODIMP mozBayesianTester::GetNegativeDocuments(nsACString& aResult) {
+#ifdef MOZILLA_INTERANL_API
+  aResult.Truncate(0);
+#else
+  aResult.Truncate();
+#endif
+  PRBool hasData;
+
+  nsresult rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIStorageStatement> statement;
+  mStorage->
+    CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM negativeDocuments"),
+                    getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    aResult.Append(statement->AsSharedUTF8String(0, nsnull));
+    aResult.AppendLiteral("\n");
+  }
+
+  return mStorage->CommitTransaction();
+}
+
+NS_IMETHODIMP mozBayesianTester::GetPositiveDocuments(nsACString& aResult) {
+#ifdef MOZILLA_INTERANL_API
+  aResult.Truncate(0);
+#else
+  aResult.Truncate();
+#endif
+  PRBool hasData;
+
+  nsresult rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIStorageStatement> statement;
+  mStorage->
+    CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM positiveDocuments"),
+                    getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    aResult.Append(statement->AsSharedUTF8String(0, nsnull));
+    aResult.AppendLiteral("\n");
+  }
+
+  return mStorage->CommitTransaction();
+}
+
+NS_IMETHODIMP mozBayesianTester::GetPositiveTokenCount(PRInt32* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  return CopyRowCounts("positiveTokens", aResult);
+}
+
+NS_IMETHODIMP mozBayesianTester::GetNegativeTokenCount(PRInt32* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  return CopyRowCounts("negativeTokens", aResult);
+}
+
+/*
+NS_IMETHODIMP mozBayesianTester::GetDump(nsACString& aResult) {
+  NS_ENSURE_TRUE(mStorage, NS_ERROR_NOT_INITIALIZED);
+#ifdef MOZILLA_INTERANL_API
+  aResult.Truncate(0);
+#else
+  aResult.Truncate();
+#endif
+
+  nsresult rv;
+  PRBool hasData;
+  nsCAutoString row, str, number;
+
+  rv = mStorage->BeginTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIStorageStatement> statement;
+  mStorage->
+    CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM positiveDocuments"),
+                    getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    aResult.Append(statement->AsSharedUTF8String(0,nsnull));
+    aResult.AppendLiteral("\n");
+  }
+  statement->Reset();
+  aResult.AppendLiteral("\n");
+
+  mStorage->CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM positiveTokens"),
+                            getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    row.Assign(statement->AsSharedUTF8String(0,nsnull));
+    row.AppendLiteral("\t\t");
+    row.AppendInt(statement->AsInt32(1));
+    row.AppendLiteral("\n");
+    aResult.Append(row);
+  }
+  statement->Reset();
+
+  aResult.AppendLiteral("\n\n\n");
+
+  mStorage->
+    CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM negativeDocuments"),
+                    getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    aResult.Append(statement->AsSharedUTF8String(0, nsnull));
+    aResult.AppendLiteral("\n");
+  }
+  statement->Reset();
+  aResult.AppendLiteral("\n");
+
+  mStorage->CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM negativeTokens"),
+                            getter_AddRefs(statement));
+
+  while(NS_SUCCEEDED(statement->ExecuteStep(&hasData)) && hasData) {
+    row.Assign(statement->AsSharedUTF8String(0, nsnull));
+    row.AppendLiteral("\t\t");
+    row.AppendInt(statement->AsInt32(1));
+    row.AppendLiteral("\n");
+    aResult.Append(row);
+  }
+  statement->Reset();
+
+  rv = mStorage->CommitTransaction();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+*/
+
+NS_IMETHODIMP mozBayesianTester::GetStrength(double *aStrength) {
+  *aStrength = mStrength;
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozBayesianTester::SetStrength(double aStrength) {
+  mStrength = aStrength;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTester::GetAssumedProbability(double *aAssumedProbability) {
+  *aAssumedProbability = mAssumedProbability;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTester::SetAssumedProbability(double aAssumedProbability) {
+  mAssumedProbability = aAssumedProbability;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTester::GetTokenizer(mozIPlainTextTokenizer * *aTokenizer) {
+  nsresult rv = EnsureTokenizerIsReady();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ADDREF(*aTokenizer = mTokenizer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTester::SetTokenizer(mozIPlainTextTokenizer * aTokenizer) {
+  mTokenizer = aTokenizer;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozBayesianTester::TrimOldTokens(PRBool aTargetIsPositiveTable,
+                                 PRInt32 aMaxTokens,
+                                 PRInt32 aThresholdCounts,
+                                 PRInt32* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = 0;
+  if ((aMaxTokens < 1) || (aThresholdCounts < 1))
+    return NS_OK;
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozBayesianTester.h
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozBayesianTester.h	2006-12-03 19:59:46.000000000 +0900
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+#ifndef __MOZ_BAYESIANTEST_TESTER__
+#define __MOZ_BAYESIANTEST_TESTER__
+
+#include "nsCOMPtr.h"
+
+#include "mozIBayesianTester.h"
+#include "mozIStorageConnection.h"
+#include "mozIStorageStatement.h"
+
+#define GR_DEFAULT_STRENGTH 1.0
+#define GR_DEFAULT_ASSUMED_PROBABILITY 0.5
+
+class mozBayesianTester : public mozIBayesianTester
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_MOZIBAYESIANTESTER
+
+  mozBayesianTester();
+  nsresult Init(nsIFile *aDBFile);
+private:
+  ~mozBayesianTester();
+  nsCOMPtr<mozIStorageConnection> mStorage;
+  nsCOMPtr<mozIPlainTextTokenizer> mTokenizer;
+  nsresult EnsureTokenizerIsReady();
+
+  double F(const char* aToken);
+
+  PRInt32 mPositiveDocuments;
+  PRInt32 mNegativeDocuments;
+
+  double mStrength;
+  double mAssumedProbability;
+
+  /* helper methods  - database reader- */
+  nsresult InitInternal();
+  nsresult EnsureTableExists(const char* aTableName, const char* aTableScheme);
+  nsresult CopyRowCounts(const char* aTableName, PRInt32* aResult);
+  nsresult CopyPositiveCounts(const char* aToken, PRInt32* aResult);
+  nsresult CopyNegativeCounts(const char* aToken, PRInt32* aResult);
+
+  /* helper methods  - database writer - */
+  nsresult AppendURI(const nsACString& aURISpec, PRBool aIsPositive);
+  nsresult InsertToken(const nsACString& aToken, PRBool aIsPositive);
+  nsresult UpdateToken(const nsACString& aToken, PRBool aIsPositive,
+                       PRInt32 aNewCount);
+
+  /* sql statmenents */
+  nsCOMPtr<mozIStorageStatement> mNegativeTokenCounter;
+  nsCOMPtr<mozIStorageStatement> mPositiveTokenCounter;
+  nsCOMPtr<mozIStorageStatement> mAppendPositiveURI;
+  nsCOMPtr<mozIStorageStatement> mAppendNegativeURI;
+  nsCOMPtr<mozIStorageStatement> mInsertPositiveToken;
+  nsCOMPtr<mozIStorageStatement> mInsertNegativeToken;
+  nsCOMPtr<mozIStorageStatement> mUpdatePositiveToken;
+  nsCOMPtr<mozIStorageStatement> mUpdateNegativeToken;
+};
+
+#endif
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozPlaintextTokenizer.h
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozPlaintextTokenizer.h	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+#ifndef __MOZ_PLAINTEXT_TOKENIZER__
+#define __MOZ__PLAINTEXT_TOKENIZER__
+
+#include "mozIBayesianTester.h"
+#include "nsVoidArray.h"
+#include "nsCOMPtr.h"
+
+// {8DEE2E47-C88D-4163-A269-47DBDD2168DF}
+#define MOZ_SIMPLE_TOKENIZER_CID \
+{0x8dee2e47, 0xc88d, 0x4163, {0xa2, 0x69, 0x47, 0xdb, 0xdd, 0x21, 0x68, 0xdf}}
+
+#define MOZ_SIMPLE_TOKENIZER_CONTRACTID \
+"@mozilla.org/extensions/bayesiantest/simpletokenizer;1"
+
+class mozSimpleTokenizer : public mozIPlainTextTokenizer
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_MOZIPLAINTEXTTOKENIZER
+  NS_DECL_NSIUTF8STRINGENUMERATOR
+
+  mozSimpleTokenizer();
+
+private:
+  ~mozSimpleTokenizer();
+  nsCStringArray mArray;
+  PRInt32 mIndex;
+  PRInt32 mIncremental;
+};
+
+// {7d7f6b33-a9c8-4a39-b933-3efd9ca4e3ab}
+#define MOZ_PLAINTEXT_TOKENIZER_JA_CID \
+{0x7d7f6b33, 0xa9c8, 0x4a39, {0xb9, 0x33, 0x3e, 0xfd, 0x9c, 0xa4, 0xe3, 0xab}}
+
+#define MOZ_PLAINTEXT_TOKENIZER_JA_CONTRACTID \
+"@mozilla.org/extensions/bayesiantest/tokenizer?lang=ja"
+
+class mozPlaintextTokenizerJA : public mozIPlainTextTokenizer
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_MOZIPLAINTEXTTOKENIZER
+  NS_DECL_NSIUTF8STRINGENUMERATOR
+
+  mozPlaintextTokenizerJA();
+
+private:
+  ~mozPlaintextTokenizerJA();
+  nsCStringArray mArray;
+  PRInt32 mIndex;
+  PRInt32 mIncremental;
+};
+
+#endif
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozPlaintextTokenizerJA.cpp
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozPlaintextTokenizerJA.cpp	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,196 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/* See bug 277354 and patchs posted by
+   Noriyuki Inoue <norinoue@mbox.kyoto-inet.or.jp> */
+
+#include <stdio.h>
+
+#include "mozPlaintextTokenizer.h"
+#define TOKEN_DELIMITERS " \t\n\r\f\\.;:,/()\""
+
+// one subtract and one conditional jump should be faster than
+// two conditional jump on most recent system.
+#define IN_RANGE(x, low, high) ((PRUint16)((x)-(low)) <= (high)-(low))
+
+#define IS_JA_HIRAGANA(x) IN_RANGE(x, 0x3040, 0x309F)
+// swapping the range using xor operation to reduce conditional jump.
+#define IS_JA_KATAKANA(x)	(IN_RANGE(x^0x0004, 0x30A0, 0x30FE) ||\
+                           IN_RANGE(x, 0xFF66, 0xFF9F))
+#define IS_JA_KANJI(x) (IN_RANGE(x, 0x2E80, 0x2FDF) ||\
+                        IN_RANGE(x, 0x4E00, 0x9FAF))
+#define IS_JA_KUTEN(x) (((x) == 0x3001) || ((x) == 0xFF64) || ((x) == 0xFF0E))
+#define IS_JA_TOUTEN(x) (((x) == 0x3002) || ((x) == 0xFF61) || ((x) == 0xFF0C))
+#define IS_JA_SPACE(x) ((x) == 0x3000)
+#define IS_JA_FWLATAIN(x) IN_RANGE(x, 0xFF01, 0xFF5E)
+#define IS_JA_FWNUMERAL(x) IN_RANGE(x, 0xFF10, 0xFF19)
+#define IS_JAPANESE_SPECIFIC(x) (IN_RANGE(x, 0x3040, 0x30FF) ||\
+                                 IN_RANGE(x, 0xFF01, 0xFF9F))
+class mozJapaneseTokenizeSupport {
+public:
+  enum char_class {
+    others = 0,
+    space,
+    hiragana,
+    katakana,
+    kanji,
+    kuten,
+    touten,
+    kigou,
+    fwlatain,
+    ascii
+  };
+
+  static char_class getCharClass (PRUnichar aChar);
+  /*
+     @pram aDocument: input string
+     @parm aTokens; pointer to the array for output.
+   */
+  static void tokenize (const nsACString& aDocument,
+                        nsCStringArray* aTokens);
+  static PRBool isJapanese(const char* aDocument);
+};
+
+/* At the moment, we don't use this method. */
+// static
+PRBool mozJapaneseTokenizeSupport::isJapanese(const char* aDocument) {
+  nsAutoString text = NS_ConvertUTF8toUTF16(aDocument);
+  PRUnichar* p = (PRUnichar*)text.get();
+  PRUnichar c;
+
+  // it is japanese chunk if it contains any hiragana or katakana.
+  while((c = *p++))
+    if( IS_JAPANESE_SPECIFIC(c))
+      return PR_TRUE;
+
+  return PR_FALSE;
+}
+
+// static
+mozJapaneseTokenizeSupport::char_class
+mozJapaneseTokenizeSupport::getCharClass(PRUnichar c) {
+  char_class charClass = others;
+
+  if(IS_JA_HIRAGANA(c))
+    charClass = hiragana;
+  else if(IS_JA_KATAKANA(c))
+    charClass = katakana;
+  else if(IS_JA_KANJI(c))
+    charClass = kanji;
+  else if(IS_JA_KUTEN(c))
+    charClass = kuten;
+  else if(IS_JA_TOUTEN(c))
+    charClass = touten;
+  else if(IS_JA_FWLATAIN(c))
+    charClass = fwlatain;
+
+  return charClass;
+}
+
+// static
+void mozJapaneseTokenizeSupport::tokenize(const nsACString& aDocument,
+                                          nsCStringArray* aTokens) {
+  nsAutoString buff = NS_ConvertUTF8toUTF16(aDocument);
+  const PRUnichar* p1 = buff.get();
+  const PRUnichar* p2 = p1;
+  if (!*p2)
+    return;
+
+  char_class cc = getCharClass(*p2);
+  while (*(++p2)) {
+    if(cc == getCharClass(*p2))
+      continue;
+
+    nsCString token = NS_ConvertUTF16toUTF8(p1, p2-p1);
+    aTokens->AppendCString(token);
+
+    cc = getCharClass(*p2);
+    p1 = p2;
+  }
+
+  if (p1 == buff.get())
+    aTokens->AppendCString(aDocument);
+}
+
+NS_IMPL_ISUPPORTS1(mozPlaintextTokenizerJA, mozIPlainTextTokenizer)
+
+mozPlaintextTokenizerJA::mozPlaintextTokenizerJA():mIndex(0), mIncremental(1) {
+}
+
+mozPlaintextTokenizerJA::~mozPlaintextTokenizerJA() {
+}
+
+NS_IMETHODIMP mozPlaintextTokenizerJA::Initialize(const nsAString& aDocument,
+                                                  PRUint32 aMaxTokens) {
+  //XXX Maybe we should implement PRUnichar version ::strtok?
+  //XXX Full-Width-Space (0x3000) should be replaced with whitespace(s)?
+
+  mArray.Clear();
+  mIndex = 0;
+
+  // First of all, tokenize per latin delimiters
+  nsCAutoString buff = NS_ConvertUTF16toUTF8(aDocument);
+  nsCStringArray fragments;
+  fragments.ParseString(buff.get(), TOKEN_DELIMITERS);
+
+  nsCString *ptr;
+  PRInt32 count = fragments.Count();
+
+  for (PRInt32 i = 0; i < count; i++) {
+    ptr = fragments.CStringAt(i);
+    if(!ptr)
+      break;
+    mozJapaneseTokenizeSupport::tokenize(*ptr, &mArray);
+  }
+
+  mArray.Sort();
+
+  if (aMaxTokens > 0)
+    mIncremental = (mArray.Count() / aMaxTokens) + 1;
+  else
+    mIncremental = 1;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozPlaintextTokenizerJA::HasMore(PRBool *_retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = (mIndex < mArray.Count());
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozPlaintextTokenizerJA::GetNext(nsACString & _retval) {
+  NS_ENSURE_TRUE((mIndex < mArray.Count()), NS_ERROR_UNEXPECTED);
+  _retval.Assign( *(mArray.CStringAt(mIndex)));
+  mIndex += mIncremental;
+  return NS_OK;
+}
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/mozSimpleTokenizer.cpp
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/mozSimpleTokenizer.cpp	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla.
+ *
+ * Contributor(s):
+ *   O. Atsushi <torisugari@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+#include "mozPlaintextTokenizer.h"
+#define TOKEN_DELIMITERS " \t\n\r\f\\.;:,/()\""
+
+NS_IMPL_ISUPPORTS1(mozSimpleTokenizer, mozIPlainTextTokenizer)
+
+mozSimpleTokenizer::mozSimpleTokenizer():mIndex(0), mIncremental(1) {
+}
+
+mozSimpleTokenizer::~mozSimpleTokenizer() {
+}
+
+NS_IMETHODIMP mozSimpleTokenizer::Initialize(const nsAString& aDocument,
+                                             PRUint32 aMaxTokens) {
+  mArray.Clear();
+  mIndex = 0;
+  /* Note: This is same as NS_Strtok(...) */
+  nsCAutoString buff = NS_ConvertUTF16toUTF8(aDocument);
+  mArray.ParseString(buff.get(), TOKEN_DELIMITERS);
+  mArray.Sort();
+
+  if (aMaxTokens > 0)
+    mIncremental = (mArray.Count() / aMaxTokens) + 1;
+  else
+    mIncremental = 1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozSimpleTokenizer::HasMore(PRBool *_retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = (mIndex < mArray.Count());
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozSimpleTokenizer::GetNext(nsACString & _retval) {
+  NS_ENSURE_TRUE((mIndex < mArray.Count()), NS_ERROR_UNEXPECTED);
+  _retval.Assign( *(mArray.CStringAt(mIndex)));
+  mIndex += mIncremental;
+  return NS_OK;
+}
diff -up8rN /dev/null mozilla/extensions/bayesiantest/src/nsIncompleteGamma.h
--- /dev/null	1970-01-01 09:00:00.000000000 +0900
+++ mozilla/extensions/bayesiantest/src/nsIncompleteGamma.h	2006-12-03 19:46:10.000000000 +0900
@@ -0,0 +1,293 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/***** BEGIN LICENSE BLOCK *****
+  Version: MPL 1.1/GPL 2.0/LGPL 2.1
+
+  The contents of this file are subject to the Mozilla Public License Version
+  1.1 (the "License"); you may not use this file except in compliance with
+  the License. You may obtain a copy of the License at
+  http://www.mozilla.org/MPL/
+
+  Software distributed under the License is distributed on an "AS IS" basis,
+  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+  for the specific language governing rights and limitations under the
+  License.
+
+  The Original Code is bayesian spam filter
+
+  The Initial Developer of the Original Code is
+  Scott MacGregor.
+  Portions created by the Initial Developer are Copyright (C) 2004
+  the Initial Developer. All Rights Reserved.
+
+  Contributor(s):
+    Scott MacGregor <mscott@mozilla.org>
+    tenthumbs@cybernex.net
+
+  Alternatively, the contents of this file may be used under the terms of
+  either of the GNU General Public License Version 2 or later (the "GPL"),
+  or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+  in which case the provisions of the GPL or the LGPL are applicable instead
+  of those above. If you wish to allow use of your version of this file only
+  under the terms of either the GPL or the LGPL, and not to allow others to
+  use your version of this file under the terms of the MPL, indicate your
+  decision by deleting the provisions above and replace them with the notice
+  and other provisions required by the GPL or the LGPL. If you do not delete
+  the provisions above, a recipient may use your version of this file under
+  the terms of any one of the MPL, the GPL or the LGPL.
+
+***** END LICENSE BLOCK *****/
+
+#ifndef nsIncompleteGamma_h__
+#define nsIncompleteGamma_h__
+
+/* An implementation of the incomplete gamma functions for real
+   arguments. P is defined as
+
+                          x
+                         /
+                  1      [     a - 1  - t
+    P(a, x) =  --------  I    t      e    dt
+               Gamma(a)  ]
+                         /
+                          0
+
+   and
+
+                          infinity
+                         /
+                  1      [     a - 1  - t
+    Q(a, x) =  --------  I    t      e    dt
+               Gamma(a)  ]
+                         /
+                          x
+
+   so that P(a,x) + Q(a,x) = 1.
+
+   Both a series expansion and a continued fraction exist.  This
+   implementation uses the more efficient method based on the arguments.
+
+   Either case involves calculating a multiplicative term:
+      e^(-x)*x^a/Gamma(a).
+   Here we calculate the log of this term. Most math libraries have a
+   "lgamma" function but it is not re-entrant. Some libraries have a
+   "lgamma_r" which is re-entrant. Use it if possible. I have included a
+   simple replacement but it is certainly not as accurate.
+
+   Relative errors are almost always < 1e-10 and usually < 1e-14. Very
+   small and very large arguments cause trouble.
+
+   The region where a < 0.5 and x < 0.5 has poor error properties and is
+   not too stable. Get a better routine if you need results in this
+   region.
+
+   The error argument will be set negative if there is a domain error or
+   positive for an internal calculation error, currently lack of
+   convergence. A value is always returned, though.
+
+ */
+
+#include <math.h>
+#include <float.h>
+
+// the main routine
+static double nsIncompleteGammaP (double a, double x, int *error);
+
+// nsLnGamma(z): either a wrapper around lgamma_r or the internal function.
+// C_m = B[2*m]/(2*m*(2*m-1)) where B is a Bernoulli number
+static const double C_1 = 1.0 / 12.0;
+static const double C_2 = -1.0 / 360.0;
+static const double C_3 = 1.0 / 1260.0;
+static const double C_4 = -1.0 / 1680.0;
+static const double C_5 = 1.0 / 1188.0;
+static const double C_6 = -691.0 / 360360.0;
+static const double C_7 = 1.0 / 156.0;
+static const double C_8 = -3617.0 / 122400.0;
+static const double C_9 = 43867.0 / 244188.0;
+static const double C_10 = -174611.0 / 125400.0;
+static const double C_11 = 77683.0 / 5796.0;
+
+// truncated asymptotic series in 1/z
+static inline double lngamma_asymp (double z)
+{
+  double w, w2, sum;
+  w = 1.0 / z;
+  w2 = w * w;
+  sum = w * (w2 * (w2 * (w2 * (w2 * (w2 * (w2 * (w2 * (w2 * (w2
+        * (C_11 * w2 + C_10) + C_9) + C_8) + C_7) + C_6)
+        + C_5) + C_4) + C_3) + C_2) + C_1);
+
+  return sum;
+}
+
+struct fact_table_s
+{
+  double fact;
+  double lnfact;
+};
+
+// for speed and accuracy
+static const struct fact_table_s FactTable[] = {
+    {1.000000000000000, 0.0000000000000000000000e+00},
+    {1.000000000000000, 0.0000000000000000000000e+00},
+    {2.000000000000000, 6.9314718055994530942869e-01},
+    {6.000000000000000, 1.7917594692280550007892e+00},
+    {24.00000000000000, 3.1780538303479456197550e+00},
+    {120.0000000000000, 4.7874917427820459941458e+00},
+    {720.0000000000000, 6.5792512120101009952602e+00},
+    {5040.000000000000, 8.5251613610654142999881e+00},
+    {40320.00000000000, 1.0604602902745250228925e+01},
+    {362880.0000000000, 1.2801827480081469610995e+01},
+    {3628800.000000000, 1.5104412573075515295248e+01},
+    {39916800.00000000, 1.7502307845873885839769e+01},
+    {479001600.0000000, 1.9987214495661886149228e+01},
+    {6227020800.000000, 2.2552163853123422886104e+01},
+    {87178291200.00000, 2.5191221182738681499610e+01},
+    {1307674368000.000, 2.7899271383840891566988e+01},
+    {20922789888000.00, 3.0671860106080672803835e+01},
+    {355687428096000.0, 3.3505073450136888885825e+01},
+    {6402373705728000., 3.6395445208033053576674e+01}
+};
+#define FactTableLength (int)(sizeof(FactTable)/sizeof(FactTable[0]))
+
+// for speed
+static const double ln_2pi_2 = 0.918938533204672741803;	// log(2*PI)/2
+
+/* A simple lgamma function, not very robust.
+
+   Valid for z_in > 0 ONLY.
+
+   For z_in > 8 precision is quite good, relative errors < 1e-14 and
+   usually better. For z_in < 8 relative errors increase but are usually
+   < 1e-10. In two small regions, 1 +/- .001 and 2 +/- .001 errors
+   increase quickly.
+*/
+static double nsLnGamma (double z_in, int *gsign)
+{
+  double scale, z, sum, result;
+  *gsign = 1;
+
+  int zi = (int) z_in;
+  if (z_in == (double) zi)
+  {
+    if (0 < zi && zi <= FactTableLength)
+	    return FactTable[zi - 1].lnfact;	// gamma(z) = (z-1)!
+  }
+
+  for (scale = 1.0, z = z_in; z < 8.0; ++z)
+    scale *= z;
+
+  sum = lngamma_asymp (z);
+  result = (z - 0.5) * log (z) - z + ln_2pi_2 - log (scale);
+  result += sum;
+  return result;
+}
+
+// log( e^(-x)*x^a/Gamma(a) )
+static inline double lnPQfactor (double a, double x)
+{
+  int gsign;				// ignored because a > 0
+  return a * log (x) - x - nsLnGamma (a, &gsign);
+}
+
+static double Pseries (double a, double x, int *error)
+{
+  double sum, term;
+  const double eps = 2.0 * DBL_EPSILON;
+  const int imax = 5000;
+  int i;
+
+  sum = term = 1.0 / a;
+  for (i = 1; i < imax; ++i)
+  {
+	  term *= x / (a + i);
+	  sum += term;
+	  if (fabs (term) < eps * fabs (sum))
+      break;
+  }
+
+  if (i >= imax)
+	  *error = 1;
+
+  return sum;
+}
+
+static double Qcontfrac (double a, double x, int *error)
+{
+  double result, D, C, e, f, term;
+  const double eps = 2.0 * DBL_EPSILON;
+  const double small =
+  DBL_EPSILON * DBL_EPSILON * DBL_EPSILON * DBL_EPSILON;
+  const int imax = 5000;
+  int i;
+
+  // modified Lentz method
+  f = x - a + 1.0;
+  if (fabs (f) < small)
+    f = small;
+  C = f + 1.0 / small;
+  D = 1.0 / f;
+  result = D;
+  for (i = 1; i < imax; ++i)
+  {
+    e = i * (a - i);
+    f += 2.0;
+    D = f + e * D;
+    if (fabs (D) < small)
+      D = small;
+    D = 1.0 / D;
+    C = f + e / C;
+    if (fabs (C) < small)
+      C = small;
+    term = C * D;
+    result *= term;
+    if (fabs (term - 1.0) < eps)
+      break;
+  }
+
+  if (i >= imax)
+    *error = 1;
+  return result;
+}
+
+static double nsIncompleteGammaP (double a, double x, int *error)
+{
+  double result, dom, ldom;
+  //  domain errors. the return values are meaningless but have
+  //  to return something.
+  *error = -1;
+  if (a <= 0.0)
+	  return 1.0;
+  if (x < 0.0)
+	  return 0.0;
+  *error = 0;
+  if (x == 0.0)
+    return 0.0;
+
+  ldom = lnPQfactor (a, x);
+  dom = exp (ldom);
+  // might need to adjust the crossover point
+  if (a <= 0.5)
+  {
+    if (x < a + 1.0)
+      result = dom * Pseries (a, x, error);
+    else
+      result = 1.0 - dom * Qcontfrac (a, x, error);
+  }
+  else
+  {
+    if (x < a)
+      result = dom * Pseries (a, x, error);
+	  else
+	    result = 1.0 - dom * Qcontfrac (a, x, error);
+  }
+
+  // not clear if this can ever happen
+  if (result > 1.0)
+    result = 1.0;
+  if (result < 0.0)
+    result = 0.0;
+  return result;
+}
+
+#endif
+