[Blimp Engine] Upates existing engine message processors to features.

BUG=568276

Review URL: https://codereview.chromium.org/1535903002

Cr-Commit-Position: refs/heads/master@{#366620}

6 files changed, 156 insertions, 106 deletions

diff --git a/blimp/engine/browser/BUILD.gn b/blimp/engine/browser/BUILD.gn
index 0bd678c..3539896 100644
--- a/blimp/engine/browser/BUILD.gn
+++ b/blimp/engine/browser/BUILD.gn
@@ -18,8 +18,8 @@ source_set("browser") {
     "blimp_permission_manager.h",
     "blimp_url_request_context_getter.cc",
     "blimp_url_request_context_getter.h",
-    "engine_render_widget_message_processor.cc",
-    "engine_render_widget_message_processor.h",
+    "engine_render_widget_feature.cc",
+    "engine_render_widget_feature.h",
   ]
 
   deps = [
@@ -44,7 +44,7 @@ source_set("unit_tests") {
   testonly = true
 
   sources = [
-    "engine_render_widget_message_processor_unittest.cc",
+    "engine_render_widget_feature_unittest.cc",
   ]
 
   deps = [
diff --git a/blimp/engine/browser/blimp_engine_session.cc b/blimp/engine/browser/blimp_engine_session.cc
index 876c6bf..412740c 100644
--- a/blimp/engine/browser/blimp_engine_session.cc
+++ b/blimp/engine/browser/blimp_engine_session.cc
@@ -4,10 +4,8 @@
 
 #include "blimp/engine/browser/blimp_engine_session.h"
 
-#include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "blimp/common/create_blimp_message.h"
-#include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/tab_control.pb.h"
 #include "blimp/engine/browser/blimp_browser_context.h"
 #include "blimp/engine/ui/blimp_layout_manager.h"
@@ -51,9 +49,6 @@ const int kDefaultDisplayWidth = 800;
 const int kDefaultDisplayHeight = 600;
 const uint16_t kDefaultPortNumber = 25467;
 
-base::LazyInstance<blimp::NullBlimpMessageProcessor> g_blimp_message_processor =
-    LAZY_INSTANCE_INITIALIZER;
-
 // Focus rules that support activating an child window.
 class FocusRulesImpl : public wm::BaseFocusRules {
  public:
@@ -122,18 +117,15 @@ BlimpEngineSession::BlimpEngineSession(
     net::NetLog* net_log)
     : browser_context_(std::move(browser_context)),
       screen_(new BlimpScreen),
-      // TODO(dtrainor, haibinlu): Properly pull these from the BlimpMessageMux.
-      render_widget_processor_(g_blimp_message_processor.Pointer(),
-                               g_blimp_message_processor.Pointer()),
       net_components_(new BlimpNetworkComponents(net_log)) {
   screen_->UpdateDisplayScaleAndSize(kDefaultScaleFactor,
                                      gfx::Size(kDefaultDisplayWidth,
                                                kDefaultDisplayHeight));
-  render_widget_processor_.SetDelegate(kDummyTabId, this);
+  render_widget_feature_.SetDelegate(kDummyTabId, this);
 }
 
 BlimpEngineSession::~BlimpEngineSession() {
-  render_widget_processor_.RemoveDelegate(kDummyTabId);
+  render_widget_feature_.RemoveDelegate(kDummyTabId);
 
   // Safely delete network components on the IO thread.
   content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
@@ -174,6 +166,31 @@ void BlimpEngineSession::Initialize() {
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&BlimpNetworkComponents::Initialize,
                  base::Unretained(net_components_.get())));
+
+  // Registers features.
+  // TODO(kmarshall) Refactor this using
+  //  1. Get outgoing message processors for blimp message types of a feature.
+  //  2. Create a feature with these outgoing message processors.
+  //  3. Register the feature as the incoming message processor for these
+  //     blimp message types.
+  tab_control_message_sender_ =
+      RegisterFeature(BlimpMessage::TAB_CONTROL, this);
+  navigation_message_sender_ = RegisterFeature(BlimpMessage::NAVIGATION, this);
+
+  render_widget_feature_.set_render_widget_message_sender(
+      RegisterFeature(BlimpMessage::RENDER_WIDGET, &render_widget_feature_));
+  render_widget_feature_.set_input_message_sender(
+      RegisterFeature(BlimpMessage::INPUT, &render_widget_feature_));
+  render_widget_feature_.set_compositor_message_sender(
+      RegisterFeature(BlimpMessage::COMPOSITOR, &render_widget_feature_));
+}
+
+scoped_ptr<BlimpMessageProcessor> BlimpEngineSession::RegisterFeature(
+    BlimpMessage::Type type,
+    BlimpMessageProcessor* incoming_processor) {
+  // TODO(haibinlu): implement this once thread hopping message processing is
+  // done.
+  return make_scoped_ptr(new NullBlimpMessageProcessor);
 }
 
 void BlimpEngineSession::CreateWebContents(const int target_tab_id) {
@@ -366,7 +383,7 @@ void BlimpEngineSession::ActivateContents(content::WebContents* contents) {
 
 void BlimpEngineSession::ForwardCompositorProto(
     const std::vector<uint8_t>& proto) {
-  render_widget_processor_.SendCompositorMessage(kDummyTabId, proto);
+  render_widget_feature_.SendCompositorMessage(kDummyTabId, proto);
 }
 
 void BlimpEngineSession::NavigationStateChanged(
@@ -396,16 +413,14 @@ void BlimpEngineSession::NavigationStateChanged(
   if (changed_flags & content::InvalidateTypes::INVALIDATE_TYPE_LOAD)
     details->set_loading(source->IsLoading());
 
-  // TODO(dtrainor, haibinlu): Send to the right BlimpMessageProcessor.
-  g_blimp_message_processor.Pointer()->ProcessMessage(
-      std::move(message),
-      net::CompletionCallback());
+  navigation_message_sender_->ProcessMessage(std::move(message),
+                                             net::CompletionCallback());
 }
 
 void BlimpEngineSession::RenderViewHostChanged(
     content::RenderViewHost* old_host,
     content::RenderViewHost* new_host) {
-  render_widget_processor_.OnRenderWidgetInitialized(kDummyTabId);
+  render_widget_feature_.OnRenderWidgetInitialized(kDummyTabId);
 }
 
 void BlimpEngineSession::PlatformSetContents(
diff --git a/blimp/engine/browser/blimp_engine_session.h b/blimp/engine/browser/blimp_engine_session.h
index 95fa551..65ebfc9 100644
--- a/blimp/engine/browser/blimp_engine_session.h
+++ b/blimp/engine/browser/blimp_engine_session.h
@@ -9,7 +9,8 @@
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "blimp/engine/browser/engine_render_widget_message_processor.h"
+#include "blimp/common/proto/blimp_message.pb.h"
+#include "blimp/engine/browser/engine_render_widget_feature.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/web_contents_delegate.h"
@@ -62,7 +63,7 @@ class BlimpEngineSession
     : public BlimpMessageProcessor,
       public content::WebContentsDelegate,
       public content::WebContentsObserver,
-      public EngineRenderWidgetMessageProcessor::RenderWidgetMessageDelegate {
+      public EngineRenderWidgetFeature::RenderWidgetMessageDelegate {
  public:
   explicit BlimpEngineSession(scoped_ptr<BlimpBrowserContext> browser_context,
                               net::NetLog* net_log);
@@ -76,11 +77,18 @@ class BlimpEngineSession
   BlimpBrowserContext* browser_context() { return browser_context_.get(); }
 
   // BlimpMessageProcessor implementation.
-  // TODO(haibinlu): Delete this and move to BlimpMessageDemultiplexer.
+  // This object handles incoming TAB_CONTROL and NAVIGATION messages.
   void ProcessMessage(scoped_ptr<BlimpMessage> message,
                       const net::CompletionCallback& callback) override;
 
  private:
+  // Registers a message processor which will receive all messages of the |type|
+  // specified.  Returns a BlimpMessageProcessor object for sending messages of
+  // type |type|.
+  scoped_ptr<BlimpMessageProcessor> RegisterFeature(
+      BlimpMessage::Type type,
+      BlimpMessageProcessor* incoming_processor);
+
   // TabControlMessage handler methods.
   // Creates a new WebContents, which will be indexed by |target_tab_id|.
   void CreateWebContents(const int target_tab_id);
@@ -147,16 +155,20 @@ class BlimpEngineSession
   // Only one web_contents is supported for blimp 0.5
   scoped_ptr<content::WebContents> web_contents_;
 
-  // The bridge to the network layer that does the RenderWidget proto/id work.
-  // TODO(dtrainor, haibinlu): Move this to a higher level once we start dealing
-  // with multiple tabs.
-  EngineRenderWidgetMessageProcessor render_widget_processor_;
-
   // Container for connection manager, authentication handler, and
   // browser connection handler. The components run on the I/O thread, and
   // this object is destroyed there.
   scoped_ptr<BlimpNetworkComponents> net_components_;
 
+  // Handles all incoming and outgoing messages related to RenderWidget,
+  // including INPUT, COMPOSITOR and RENDER_WIDGET messages.
+  // TODO(dtrainor, haibinlu): Move this to a higher level once we start dealing
+  // with multiple tabs.
+  EngineRenderWidgetFeature render_widget_feature_;
+
+  scoped_ptr<BlimpMessageProcessor> tab_control_message_sender_;
+  scoped_ptr<BlimpMessageProcessor> navigation_message_sender_;
+
   DISALLOW_COPY_AND_ASSIGN(BlimpEngineSession);
 };
 
diff --git a/blimp/engine/browser/engine_render_widget_message_processor.cc b/blimp/engine/browser/engine_render_widget_feature.cc
index 6e377dc..7beaaaf 100644
--- a/blimp/engine/browser/engine_render_widget_message_processor.cc
+++ b/blimp/engine/browser/engine_render_widget_feature.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "blimp/engine/browser/engine_render_widget_message_processor.h"
+#include "blimp/engine/browser/engine_render_widget_feature.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "blimp/common/create_blimp_message.h"
@@ -15,22 +15,29 @@
 
 namespace blimp {
 
-EngineRenderWidgetMessageProcessor::EngineRenderWidgetMessageProcessor(
-    BlimpMessageProcessor* render_widget_message_processor,
-    BlimpMessageProcessor* compositor_message_processor)
-    : render_widget_message_processor_(render_widget_message_processor),
-      compositor_message_processor_(compositor_message_processor) {
-  // TODO(dtrainor): Register as a BlimpMessageProcessor for
-  // BlimpMessage::INPUT and BlimpMessage::COMPOSITOR messages.
+EngineRenderWidgetFeature::EngineRenderWidgetFeature() {}
+
+EngineRenderWidgetFeature::~EngineRenderWidgetFeature() {}
+
+void EngineRenderWidgetFeature::set_render_widget_message_sender(
+    scoped_ptr<BlimpMessageProcessor> message_processor) {
+  DCHECK(message_processor);
+  render_widget_message_sender_ = std::move(message_processor);
 }
 
-EngineRenderWidgetMessageProcessor::~EngineRenderWidgetMessageProcessor() {
-  // TODO(dtrainor): Unregister as a BlimpMessageProcessor for
-  // BlimpMessage::INPUT and BlimpMessage::COMPOSITOR messages.
+void EngineRenderWidgetFeature::set_input_message_sender(
+    scoped_ptr<BlimpMessageProcessor> message_processor) {
+  DCHECK(message_processor);
+  input_message_sender_ = std::move(message_processor);
 }
 
-void EngineRenderWidgetMessageProcessor::OnRenderWidgetInitialized(
-    const int tab_id) {
+void EngineRenderWidgetFeature::set_compositor_message_sender(
+    scoped_ptr<BlimpMessageProcessor> message_processor) {
+  DCHECK(message_processor);
+  compositor_message_sender_ = std::move(message_processor);
+}
+
+void EngineRenderWidgetFeature::OnRenderWidgetInitialized(const int tab_id) {
   render_widget_ids_[tab_id] = GetRenderWidgetId(tab_id) + 1;
 
   RenderWidgetMessage* render_widget_message;
@@ -39,11 +46,11 @@ void EngineRenderWidgetMessageProcessor::OnRenderWidgetInitialized(
   render_widget_message->set_type(RenderWidgetMessage::INITIALIZE);
   render_widget_message->set_render_widget_id(GetRenderWidgetId(tab_id));
 
-  render_widget_message_processor_->ProcessMessage(std::move(blimp_message),
-                                                   net::CompletionCallback());
+  render_widget_message_sender_->ProcessMessage(std::move(blimp_message),
+                                                net::CompletionCallback());
 }
 
-void EngineRenderWidgetMessageProcessor::SendCompositorMessage(
+void EngineRenderWidgetFeature::SendCompositorMessage(
     const int tab_id,
     const std::vector<uint8_t>& message) {
   CompositorMessage* compositor_message;
@@ -58,26 +65,28 @@ void EngineRenderWidgetMessageProcessor::SendCompositorMessage(
   compositor_message->set_payload(message.data(),
                                   base::checked_cast<int>(message.size()));
 
-  render_widget_message_processor_->ProcessMessage(std::move(blimp_message),
-                                                   net::CompletionCallback());
+  render_widget_message_sender_->ProcessMessage(std::move(blimp_message),
+                                                net::CompletionCallback());
 }
 
-void EngineRenderWidgetMessageProcessor::SetDelegate(
-    const int tab_id, RenderWidgetMessageDelegate* delegate) {
+void EngineRenderWidgetFeature::SetDelegate(
+    const int tab_id,
+    RenderWidgetMessageDelegate* delegate) {
   DCHECK(!FindDelegate(tab_id));
   delegates_[tab_id] = delegate;
 }
 
-void EngineRenderWidgetMessageProcessor::RemoveDelegate(const int tab_id) {
+void EngineRenderWidgetFeature::RemoveDelegate(const int tab_id) {
   DelegateMap::iterator it = delegates_.find(tab_id);
   if (it != delegates_.end())
     delegates_.erase(it);
 }
 
-void EngineRenderWidgetMessageProcessor::ProcessMessage(
+void EngineRenderWidgetFeature::ProcessMessage(
     scoped_ptr<BlimpMessage> message,
     const net::CompletionCallback& callback) {
-  DCHECK(message->type() == BlimpMessage::INPUT ||
+  DCHECK(message->type() == BlimpMessage::RENDER_WIDGET ||
+         message->type() == BlimpMessage::INPUT ||
          message->type() == BlimpMessage::COMPOSITOR);
 
   int target_tab_id = message->target_tab_id();
@@ -114,17 +123,15 @@ void EngineRenderWidgetMessageProcessor::ProcessMessage(
   }
 }
 
-EngineRenderWidgetMessageProcessor::RenderWidgetMessageDelegate*
-EngineRenderWidgetMessageProcessor::FindDelegate(
-    const int tab_id) {
+EngineRenderWidgetFeature::RenderWidgetMessageDelegate*
+EngineRenderWidgetFeature::FindDelegate(const int tab_id) {
   DelegateMap::const_iterator it = delegates_.find(tab_id);
   if (it != delegates_.end())
     return it->second;
   return nullptr;
 }
 
-uint32_t EngineRenderWidgetMessageProcessor::GetRenderWidgetId(
-    const int tab_id) {
+uint32_t EngineRenderWidgetFeature::GetRenderWidgetId(const int tab_id) {
   RenderWidgetIdMap::const_iterator it = render_widget_ids_.find(tab_id);
   if (it != render_widget_ids_.end())
     return it->second;
diff --git a/blimp/engine/browser/engine_render_widget_message_processor.h b/blimp/engine/browser/engine_render_widget_feature.h
index 3562c3b..7f89516 100644
--- a/blimp/engine/browser/engine_render_widget_message_processor.h
+++ b/blimp/engine/browser/engine_render_widget_feature.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef BLIMP_ENGINE_BROWSER_ENGINE_RENDER_WIDGET_MESSAGE_PROCESSOR_H_
-#define BLIMP_ENGINE_BROWSER_ENGINE_RENDER_WIDGET_MESSAGE_PROCESSOR_H_
+#ifndef BLIMP_ENGINE_BROWSER_ENGINE_RENDER_WIDGET_FEATURE_H_
+#define BLIMP_ENGINE_BROWSER_ENGINE_RENDER_WIDGET_FEATURE_H_
 
 #include <stdint.h>
 
@@ -27,7 +27,7 @@ namespace blimp {
 // notified of incoming messages. This class automatically handles dropping
 // stale BlimpMessage::RENDER_WIDGET messages from the client after a
 // RenderWidgetMessage::INITIALIZE message is sent.
-class EngineRenderWidgetMessageProcessor : public BlimpMessageProcessor {
+class EngineRenderWidgetFeature : public BlimpMessageProcessor {
  public:
   // A delegate to be notified of specific RenderWidget related incoming events.
   class RenderWidgetMessageDelegate {
@@ -42,10 +42,17 @@ class EngineRenderWidgetMessageProcessor : public BlimpMessageProcessor {
         const std::vector<uint8_t>& message) = 0;
   };
 
-  EngineRenderWidgetMessageProcessor(
-      BlimpMessageProcessor* render_widget_message_processor,
-      BlimpMessageProcessor* compositor_message_processor);
-  ~EngineRenderWidgetMessageProcessor() override;
+  EngineRenderWidgetFeature();
+  ~EngineRenderWidgetFeature() override;
+
+  void set_render_widget_message_sender(
+      scoped_ptr<BlimpMessageProcessor> message_processor);
+
+  void set_input_message_sender(
+      scoped_ptr<BlimpMessageProcessor> message_processor);
+
+  void set_compositor_message_sender(
+      scoped_ptr<BlimpMessageProcessor> message_processor);
 
   // Notifies the client that the RenderWidget for a particular WebContents has
   // changed.  When this is sent all incoming messages from the client sent
@@ -80,14 +87,21 @@ class EngineRenderWidgetMessageProcessor : public BlimpMessageProcessor {
   DelegateMap delegates_;
   RenderWidgetIdMap render_widget_ids_;
 
+  // TODO(haibinlu): rename InputMessageProcessor.
   InputMessageProcessor input_message_processor_;
 
-  BlimpMessageProcessor* render_widget_message_processor_;
-  BlimpMessageProcessor* compositor_message_processor_;
+  // Message processor for sending RENDER_WIDGET messages.
+  scoped_ptr<BlimpMessageProcessor> render_widget_message_sender_;
+
+  // Message processor for sending COMPOSITOR messages.
+  scoped_ptr<BlimpMessageProcessor> compositor_message_sender_;
+
+  // Message processor for sending INPUT messages.
+  scoped_ptr<BlimpMessageProcessor> input_message_sender_;
 
-  DISALLOW_COPY_AND_ASSIGN(EngineRenderWidgetMessageProcessor);
+  DISALLOW_COPY_AND_ASSIGN(EngineRenderWidgetFeature);
 };
 
 }  // namespace blimp
 
-#endif  // BLIMP_ENGINE_BROWSER_ENGINE_RENDER_WIDGET_MESSAGE_PROCESSOR_H_
+#endif  // BLIMP_ENGINE_BROWSER_ENGINE_RENDER_WIDGET_FEATURE_H_
diff --git a/blimp/engine/browser/engine_render_widget_message_processor_unittest.cc b/blimp/engine/browser/engine_render_widget_feature_unittest.cc
index 82a06df..9eba4c8 100644
--- a/blimp/engine/browser/engine_render_widget_message_processor_unittest.cc
+++ b/blimp/engine/browser/engine_render_widget_feature_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "blimp/engine/browser/engine_render_widget_message_processor.h"
+#include "blimp/engine/browser/engine_render_widget_feature.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ -27,9 +27,9 @@ namespace blimp {
 namespace {
 
 class MockHostRenderWidgetMessageDelegate
-    : public EngineRenderWidgetMessageProcessor::RenderWidgetMessageDelegate {
+    : public EngineRenderWidgetFeature::RenderWidgetMessageDelegate {
  public:
-  // EngineRenderWidgetMessageProcessor implementation.
+  // EngineRenderWidgetFeature implementation.
   void OnWebInputEvent(scoped_ptr<blink::WebInputEvent> event) override {
     MockableOnWebInputEvent();
   }
@@ -100,27 +100,30 @@ void SendCompositorMessage(BlimpMessageProcessor* processor,
 
 }  // namespace
 
-class EngineRenderWidgetMessageProcessorTest : public testing::Test {
+class EngineRenderWidgetFeatureTest : public testing::Test {
  public:
-  EngineRenderWidgetMessageProcessorTest()
-      : processor_(&out_processor_, &out_processor_) {}
+  EngineRenderWidgetFeatureTest() {}
 
   void SetUp() override {
-    processor_.SetDelegate(1, &delegate1_);
-    processor_.SetDelegate(2, &delegate2_);
+    render_widget_message_sender_ = new MockBlimpMessageProcessor;
+    feature_.set_render_widget_message_sender(
+        make_scoped_ptr(render_widget_message_sender_));
+    feature_.SetDelegate(1, &delegate1_);
+    feature_.SetDelegate(2, &delegate2_);
   }
 
  protected:
-  MockBlimpMessageProcessor out_processor_;
+  MockBlimpMessageProcessor* render_widget_message_sender_;
   MockHostRenderWidgetMessageDelegate delegate1_;
   MockHostRenderWidgetMessageDelegate delegate2_;
-  EngineRenderWidgetMessageProcessor processor_;
+  EngineRenderWidgetFeature feature_;
 };
 
-TEST_F(EngineRenderWidgetMessageProcessorTest, DelegateCallsOK) {
+TEST_F(EngineRenderWidgetFeatureTest, DelegateCallsOK) {
   std::vector<uint8_t> payload = { 'd', 'a', 'v', 'i', 'd' };
 
-  EXPECT_CALL(out_processor_, MockableProcessMessage(_, _)).Times(2);
+  EXPECT_CALL(*render_widget_message_sender_, MockableProcessMessage(_, _))
+      .Times(2);
   EXPECT_CALL(delegate1_,
               MockableOnCompositorMessageReceived(CompMsgEquals(payload)))
       .Times(1);
@@ -130,68 +133,67 @@ TEST_F(EngineRenderWidgetMessageProcessorTest, DelegateCallsOK) {
       .Times(1);
   EXPECT_CALL(delegate2_, MockableOnWebInputEvent()).Times(0);
 
-  processor_.OnRenderWidgetInitialized(1);
-  processor_.OnRenderWidgetInitialized(2);
-  SendCompositorMessage(&processor_, 1, 1U, payload);
-  SendInputMessage(&processor_, 1, 1U);
-  SendCompositorMessage(&processor_, 2, 1U, payload);
+  feature_.OnRenderWidgetInitialized(1);
+  feature_.OnRenderWidgetInitialized(2);
+  SendCompositorMessage(&feature_, 1, 1U, payload);
+  SendInputMessage(&feature_, 1, 1U);
+  SendCompositorMessage(&feature_, 2, 1U, payload);
 }
 
-TEST_F(EngineRenderWidgetMessageProcessorTest, DropsStaleMessages) {
+TEST_F(EngineRenderWidgetFeatureTest, DropsStaleMessages) {
   InSequence sequence;
   std::vector<uint8_t> payload = { 'f', 'u', 'n' };
   std::vector<uint8_t> new_payload = {'n', 'o', ' ', 'f', 'u', 'n'};
 
-  EXPECT_CALL(out_processor_,
+  EXPECT_CALL(*render_widget_message_sender_,
               MockableProcessMessage(BlimpRWMsgEquals(1, 1U), _));
   EXPECT_CALL(delegate1_,
               MockableOnCompositorMessageReceived(CompMsgEquals(payload)));
-  EXPECT_CALL(out_processor_,
+  EXPECT_CALL(*render_widget_message_sender_,
               MockableProcessMessage(BlimpRWMsgEquals(1, 2U), _));
   EXPECT_CALL(delegate1_,
               MockableOnCompositorMessageReceived(CompMsgEquals(new_payload)));
   EXPECT_CALL(delegate1_, MockableOnWebInputEvent());
 
-  processor_.OnRenderWidgetInitialized(1);
-  SendCompositorMessage(&processor_, 1, 1U, payload);
-  processor_.OnRenderWidgetInitialized(1);
+  feature_.OnRenderWidgetInitialized(1);
+  SendCompositorMessage(&feature_, 1, 1U, payload);
+  feature_.OnRenderWidgetInitialized(1);
 
   // These next three calls should be dropped.
-  SendCompositorMessage(&processor_, 1, 1U, payload);
-  SendCompositorMessage(&processor_, 1, 1U, payload);
-  SendInputMessage(&processor_, 1, 1U);
+  SendCompositorMessage(&feature_, 1, 1U, payload);
+  SendCompositorMessage(&feature_, 1, 1U, payload);
+  SendInputMessage(&feature_, 1, 1U);
 
-  SendCompositorMessage(&processor_, 1, 2U, new_payload);
-  SendInputMessage(&processor_, 1, 2U);
+  SendCompositorMessage(&feature_, 1, 2U, new_payload);
+  SendInputMessage(&feature_, 1, 2U);
 }
 
-TEST_F(EngineRenderWidgetMessageProcessorTest,
-       RepliesHaveCorrectRenderWidgetId) {
+TEST_F(EngineRenderWidgetFeatureTest, RepliesHaveCorrectRenderWidgetId) {
   Sequence delegate1_sequence;
   Sequence delegate2_sequence;
   std::vector<uint8_t> payload = { 'a', 'b', 'c', 'd' };
 
-  EXPECT_CALL(out_processor_,
+  EXPECT_CALL(*render_widget_message_sender_,
               MockableProcessMessage(BlimpRWMsgEquals(1, 1U), _))
       .InSequence(delegate1_sequence);
-  EXPECT_CALL(out_processor_,
+  EXPECT_CALL(*render_widget_message_sender_,
               MockableProcessMessage(BlimpRWMsgEquals(1, 2U), _))
       .InSequence(delegate1_sequence);
-  EXPECT_CALL(out_processor_,
+  EXPECT_CALL(*render_widget_message_sender_,
               MockableProcessMessage(BlimpCompMsgEquals(1, 2U, payload), _))
       .InSequence(delegate1_sequence);
-  EXPECT_CALL(out_processor_,
+  EXPECT_CALL(*render_widget_message_sender_,
               MockableProcessMessage(BlimpRWMsgEquals(2, 1U), _))
       .InSequence(delegate2_sequence);
-  EXPECT_CALL(out_processor_,
+  EXPECT_CALL(*render_widget_message_sender_,
               MockableProcessMessage(BlimpRWMsgEquals(2, 2U), _))
       .InSequence(delegate2_sequence);
 
-  processor_.OnRenderWidgetInitialized(1);
-  processor_.OnRenderWidgetInitialized(2);
-  processor_.OnRenderWidgetInitialized(1);
-  processor_.OnRenderWidgetInitialized(2);
-  processor_.SendCompositorMessage(1, payload);
+  feature_.OnRenderWidgetInitialized(1);
+  feature_.OnRenderWidgetInitialized(2);
+  feature_.OnRenderWidgetInitialized(1);
+  feature_.OnRenderWidgetInitialized(2);
+  feature_.SendCompositorMessage(1, payload);
 }