In-te-grate hy-phen-ator to con-tent.

content/renderer/hyphenator/hyphenator.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/hyphenator/hyphenator.h"
 
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "content/common/hyphenator_messages.h"
+#include "content/public/renderer/render_thread.h"

[jam, 2012/08/23 21:34:29]

nit: not needed

[Hironori Bono, 2012/08/27 06:57:28]

Done. I have removed redundant headers. (I do not need some other header files
because I used the RenderProcessObserver class.)

+#include "content/renderer/render_thread_impl.h"
+#include "ipc/ipc_channel_proxy.h"
 #include "third_party/hyphen/hyphen.h"
 #include "unicode/uscript.h"
 
 namespace {
 
 // A class that converts a sequence of UTF-8 characters to UTF-16 ones and holds
 // only the length of converted UTF-16 characters. This class is used for
 // creating a mapping from the position of a UTF-8 string to a position of a
 // UTF-16 string without unnecessary conversions. Even though the following
 // snippet produces the same mapping, it needs to convert same characters many
@@ skipping 147 matching lines @@
   UTF16TextLength text_length;
   hyphen_offsets->clear();
   for (size_t i = 0; i < word_utf8_.length(); ++i) {
     text_length.Append(word_utf8_[i]);
     if (hyphen_vector_[i] & 1)
       hyphen_offsets->push_back(text_length.utf16_length());
   }
   return !hyphen_offsets->empty();
 }
 
+// A message filter that listens HyphenatorMsg_SetDictionary messages and
+// initializes the specified Hyphenator object. This class has a weak reference
+// to the Hyphenator object so a renderer can delete it while a browser opens a
+// dictionary file.
+class MessageFilter : public IPC::ChannelProxy::MessageFilter {

[jam, 2012/08/23 21:34:29]

you don't need a message filter, since you're really dispatching this message on
the main renderer thread (a message filter would be helpful if you needed to
dispatch it on the IO thread).

you can make the Hyphenator class derive from RenderProcessObserver and register
with RenderThread. that way you can dispatch messages on the main thread

[Hironori Bono, 2012/08/27 06:57:28]

Done. Thanks for your suggestion. The RenderProcessObserver class makes this
change much simpler.

+ public:
+  explicit MessageFilter(base::WeakPtr<content::Hyphenator> hyphenator);
+
+  // IPC::ChannelProxy::MessageFilter implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+ private:
+  virtual ~MessageFilter();
+
+  // Called when a browser sends a HyphenatorMsg_SetDictionary message, i.e.

[jam, 2012/08/23 21:34:29]

nit: by convention we don't comment IPC message handlers. the comment for those
is in their _messages.h file

[Hironori Bono, 2012/08/27 06:57:28]

Done. Thanks for your comment. (I have removed comments in header files.)

+  // when a browser opens the hyphenation dictionary requested by the
+  // Hyphenator object.
+  void OnSetDictionary(IPC::PlatformFileForTransit rule_file);
+
+  base::WeakPtr<content::Hyphenator> hyphenator_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
+};
+
+MessageFilter::MessageFilter(base::WeakPtr<content::Hyphenator> hyphenator)
+    : hyphenator_(hyphenator),
+      message_loop_(base::MessageLoopProxy::current()) {
+}
+
+MessageFilter::~MessageFilter() {
+}
+
+bool MessageFilter::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(MessageFilter, message)
+    IPC_MESSAGE_HANDLER(HyphenatorMsg_SetDictionary, OnSetDictionary)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void MessageFilter::OnSetDictionary(IPC::PlatformFileForTransit rule_file) {
+  base::PlatformFile file =
+      IPC::PlatformFileForTransitToPlatformFile(rule_file);
+  if (file == base::kInvalidPlatformFileValue)
+    return;
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&content::Hyphenator::SetDictionary, hyphenator_, file));
+}
+
 }  // namespace
 
 namespace content {
 
 Hyphenator::Hyphenator(base::PlatformFile file)
     : dictionary_(NULL),
       rule_file_(file),
-      result_(0) {
+      result_(0),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 Hyphenator::~Hyphenator() {
   if (dictionary_)
     hnj_hyphen_free(dictionary_);
+  if (rule_file_ != base::kInvalidPlatformFileValue)
+    base::ClosePlatformFile(rule_file_);
 }
 
 bool Hyphenator::Initialize() {
   if (dictionary_)
     return true;
 
+  // Attach the dictionary file to the MemoryMappedFile object. When it
+  // succeeds, this class does not have to close this file because it is closed
+  // by the MemoryMappFile class. To prevent this class from closing this file,

[tony, 2012/08/22 19:05:50]

Nit: typo: MemoryMappFile -> MemoryMappedFile

[Hironori Bono, 2012/08/27 06:57:28]

Done. Thanks for noticing my typo.

+  // we reset its handle.
   rule_map_.reset(new file_util::MemoryMappedFile);
   if (!rule_map_->Initialize(rule_file_))
     return false;
+  rule_file_ = base::kInvalidPlatformFileValue;
 
   dictionary_ = hnj_hyphen_load(rule_map_->data(), rule_map_->length());
   return !!dictionary_;
 }
 
+bool Hyphenator::Attach(content::RenderThread* thread, const string16& locale) {

[jam, 2012/08/23 21:34:29]

ditto

[Hironori Bono, 2012/08/27 06:57:28]

Done. I have removed this redundant comment.

+  // Create a new message filter for Hyphenator messages and attach it to the
+  // given thread with a weak reference to this object so a renderer can delete
+  // this object while a browser opens a dictionary.
+  if (!thread)
+    return false;
+  locale_.assign(locale);
+  thread->AddFilter(new MessageFilter(weak_factory_.GetWeakPtr()));
+  return thread->Send(new HyphenatorHostMsg_OpenDictionary(locale));
+}
+
+bool Hyphenator::CanHyphenate(const string16& locale) {
+  return !locale_.compare(locale);
+}
+
 size_t Hyphenator::ComputeLastHyphenLocation(const string16& word,
                                              size_t before_index) {
-  if (!dictionary_ || word.empty())
+  if (!Initialize() || word.empty())
     return 0;
 
   // Call the hyphen library to get all hyphenation points, i.e. positions where
   // we can insert hyphens. When WebKit finds a line-break, it calls this
   // function twice or more with the same word to find the best hyphenation
   // point. To avoid calling the hyphen library twice or more with the same
   // word, we cache the last query.
   if (word_ != word) {
     word_ = word;
     Query query(word);
     result_ = query.Hyphenate(dictionary_, &hyphen_offsets_);
   }
   if (!result_)
     return 0;
   for (std::vector<int>::reverse_iterator it = hyphen_offsets_.rbegin();
        it != hyphen_offsets_.rend(); ++it) {
     if (static_cast<size_t>(*it) < before_index)
       return *it;
   }
   return 0;
 }
 
+void Hyphenator::SetDictionary(base::PlatformFile rule_file) {
+  // Delete the current dictionary and save the given file to this object. We
+  // initialize the hyphens library the first time when WebKit actually
+  // hyphenates a word, i.e. when WebKit calls the ComputeLastHyphenLocation
+  // function. (WebKit does not always hyphenate words even when it calls the
+  // CanHyphenate function, e.g. WebKit does not have to hyphenate words when it
+  // does not have to break text into lines.)
+  DCHECK(rule_file != base::kInvalidPlatformFileValue);
+  if (dictionary_) {
+    hnj_hyphen_free(dictionary_);
+    dictionary_ = NULL;
+  }
+  rule_map_.reset();
+  rule_file_ = rule_file;
+}
+
 }  // namespace content