Integrate the Spelling service to Chrome.

chrome/browser/tab_contents/render_view_context_menu.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_TAB_CONTENTS_RENDER_VIEW_CONTEXT_MENU_H_
 #define CHROME_BROWSER_TAB_CONTENTS_RENDER_VIEW_CONTEXT_MENU_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/observer_list.h"
 #include "base/string16.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/extensions/extension_menu_manager.h"
+#include "chrome/browser/tab_contents/render_view_context_menu_observer.h"
 #include "content/common/page_transition_types.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "webkit/glue/context_menu.h"
 #include "webkit/glue/window_open_disposition.h"
 
 class ExtensionMenuItem;
 class Profile;
+class RenderViewHost;
 class TabContents;
+class SpellingMenuObserver;
 
 namespace gfx {
 class Point;
 }
 
 namespace WebKit {
 struct WebMediaPlayerAction;
 }
 
-class RenderViewContextMenu : public ui::SimpleMenuModel::Delegate {
+// An interface that controls a RenderViewContextMenu instance from observers.
+// This interface is designed mainly for controling the instance while showing

[Avi (use Gerrit), 2011/08/23 18:38:19]

typo: controlling

[Hironori Bono, 2011/08/25 11:18:58]

Done.

+// so we can add a context-menu item that takes long time to create its text,
+// such as retrieving the item text from a server. The simplest usage is:
+// 1. Adding an item with temporary text;
+// 2. Posting a background task that creates the item text, and;
+// 3. Calling UpdateMenuItem() in the callback function.
+// The following snippet describes the simple usage that updates a context-menu
+// item with this interface.
+//
+//   class MyTask : public URLFetcher::Delegate {
+//    public:
+//     MyTask(RenderViewContextMenuDelegate* delegate, int id)
+//         : delegate_(delegate),
+//           id_(id) {
+//     }
+//     virtual ~MyTask() {
+//     }
+//     virtual void OnURLFetchComplete(const URLFetcher* source,
+//                                     const GURL& url,
+//                                     const net::URLRequestStatus& status,
+//                                     int response,
+//                                     const net::ResponseCookies& cookies,
+//                                     const std::string& data) {
+//       bool enabled = respose == 200;

[Avi (use Gerrit), 2011/08/23 18:38:19]

response

[Hironori Bono, 2011/08/25 11:18:58]

Done.

+//       const char* text = enabled ? "OK" : "ERROR";
+//       delegate_->UpdateMenuItem(id_, enabled, ASCIIToUTF16(text));
+//     }
+//     void Start(const GURL* url, net::URLRequestContextGetter* context) {
+//       fetcher_.reset(new URLFetcher(url, URLFetcher::GET, this));
+//       fetcher_->set_request_context(context);
+//       fetcher_->Start();
+//     }
+//
+//    private:
+//     URLFetcher fetcher_;
+//     RenderViewContextMenuDelegate* delegate_;
+//     int id_;
+//   };
+//
+//   void RenderViewContextMenu::AppendEditableItems() {
+//     // Add a menu item with temporary text shown while we create the final
+//     // text.
+//     menu_model_.AddItemWithStringId(IDC_MY_ITEM, IDC_MY_TEXT);
+//
+//     // Start a task that creates the final text.
+//     my_task_ = new MyTask(this, IDC_MY_ITEM);
+//     my_task_->Start(...);
+//   }
+//
+class RenderViewContextMenuDelegate {

[Avi (use Gerrit), 2011/08/23 18:38:19]

This naming seems backwards from most usage of the term "delegate". An
XXXXDelegate is implemented by a class that "owns" the XXXX, and is consulted by
the XXXX for policy decisions/upward delegation.

For example, see TabContents/TabContentsDelegate,
RenderViewHost/RenderViewHostDelegate,
RenderViewHostManager/RenderViewHostManager::Delegate, etc. I'm not aware of an
XXXXDelegate interface that the XXXX itself implements.

[Hironori Bono, 2011/08/25 11:18:58]

Thank you for your description. This is just caused by my poor naming sense.
Even though I have renamed this interface to RenderViewContextMenuProxy, I'm
wondering if it is good. Is it possible to give me suggestions if it does not
make sense to you?

[Avi (use Gerrit), 2011/08/25 14:59:12]

That's better. I'm struggling to come up with a good name; what do you call an
interface that implements a menu?

[Hironori Bono, 2011/08/29 08:17:04]

It is a good question. I initially tried to split this RenderViewContextMenu
into a model, a view, and a controller so we can denoted this interface as
RenderViewContextMenuController. Unfortunately, while implementing this change,
I wondered if this is really a controller and started finding better names. This
is the beginning of my naming struggle.

+ public:
+  // Add a menu item to a context menu.
+  virtual void AddMenuItem(int command_id, const string16& title) = 0;
+
+  // Update the stauts and text of the specified context-menu item.

[Avi (use Gerrit), 2011/08/23 18:38:19]

status

[Hironori Bono, 2011/08/25 11:18:58]

Done.

+  virtual void UpdateMenuItem(int command_id,
+                              bool enabled,
+                              const string16& title) = 0;
+
+  // Retrieve the RenderViewHost (or Profile) instance associated with a context
+  // menu, respectively.
+  virtual RenderViewHost* GetRenderViewHost() const = 0;
+  virtual Profile* GetProfile() const = 0;
+};
+
+class RenderViewContextMenu : public ui::SimpleMenuModel::Delegate,
+                              public RenderViewContextMenuDelegate {
  public:
   static const size_t kMaxExtensionItemTitleLength;
   static const size_t kMaxSelectionTextLength;
 
   RenderViewContextMenu(TabContents* tab_contents,
                         const ContextMenuParams& params);
 
   virtual ~RenderViewContextMenu();
 
   // Initializes the context menu.
   void Init();
 
   // Provide access to the menu model for ExternalTabContainer.
   const ui::MenuModel& menu_model() const { return menu_model_; }
 
   // SimpleMenuModel::Delegate implementation.
   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
   virtual void ExecuteCommand(int command_id) OVERRIDE;
   virtual void MenuWillShow(ui::SimpleMenuModel* source) OVERRIDE;
   virtual void MenuClosed(ui::SimpleMenuModel* source) OVERRIDE;
 
+  // RenderViewContextMenuDelegate implementation.
+  virtual void AddMenuItem(int command_id, const string16& title) OVERRIDE;
+  virtual void UpdateMenuItem(int command_id,
+                              bool enabled,
+                              const string16& title) OVERRIDE;
+  virtual RenderViewHost* GetRenderViewHost() const;
+  virtual Profile* GetProfile() const;
+
  protected:
   void InitMenu();
 
   // Platform specific functions.
   virtual void PlatformInit() = 0;
   virtual bool GetAcceleratorForCommandId(
       int command_id,
       ui::Accelerator* accelerator) = 0;
   virtual void LookUpInDictionary();
 
@@ skipping 95 matching lines @@
   // a text selection.
   GURL selection_navigation_url_;
 
   ui::SimpleMenuModel spellcheck_submenu_model_;
   ui::SimpleMenuModel speech_input_submenu_model_;
   ui::SimpleMenuModel bidi_submenu_model_;
   ui::SimpleMenuModel protocol_handler_submenu_model_;
   ScopedVector<ui::SimpleMenuModel> extension_menu_models_;
   scoped_refptr<ProtocolHandlerRegistry> protocol_handler_registry_;
 
+  // An observer that handles a spelling-menu items.
+  scoped_ptr<SpellingMenuObserver> spelling_menu_observer_;
+
+  // Our observers.
+  mutable ObserverList<RenderViewContextMenuObserver> observers_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderViewContextMenu);
 };
 
 #endif  // CHROME_BROWSER_TAB_CONTENTS_RENDER_VIEW_CONTEXT_MENU_H_