blimp: Add settings to allow the client to download the whole page.

blimp/engine/feature/engine_render_widget_feature.cc

 // Copyright 2015 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 "blimp/engine/feature/engine_render_widget_feature.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/compositor.pb.h"
 #include "blimp/common/proto/input.pb.h"
 #include "blimp/common/proto/render_widget.pb.h"
 #include "content/public/browser/render_widget_host.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 namespace blimp {
 
-EngineRenderWidgetFeature::EngineRenderWidgetFeature() {}
+EngineRenderWidgetFeature::EngineRenderWidgetFeature(
+    EngineSettingsFeature* settings)
+    : settings_feature_(settings) {
+  DCHECK(settings_feature_);
+  settings_feature_->AddObserver(this);

[haibinlu, 2016/03/21 18:25:22]

Shall we avoid dependency between features?

Discussed with Kevin on the design. we can have a simple Settings object owned
by SettingsManager, which is owned by EngineSession.

SettingsManager has the nested observer (add/remove observer). 

   --Add/RemoveObserver
   --UpdateSettings(Settings&) // called by SettingsFeature
   --Settings settings()
   --Observer
      * OnSettingsUpdated()

WDYT?

[Khushal, 2016/03/22 04:11:42]

Sounds like a great idea. I looked at the code again, and it made sense to add a
simple object for all the settings, I've added it as EngineSettings.

+}
 
-EngineRenderWidgetFeature::~EngineRenderWidgetFeature() {}
+EngineRenderWidgetFeature::~EngineRenderWidgetFeature() {
+  DCHECK(settings_feature_);
+  settings_feature_->RemoveObserver(this);
+}
 
 void EngineRenderWidgetFeature::set_render_widget_message_sender(
     scoped_ptr<BlimpMessageProcessor> message_processor) {
   DCHECK(message_processor);
   render_widget_message_sender_ = std::move(message_processor);
 }
 
 void EngineRenderWidgetFeature::set_input_message_sender(
     scoped_ptr<BlimpMessageProcessor> message_processor) {
   DCHECK(message_processor);
   input_message_sender_ = std::move(message_processor);
 }
 
 void EngineRenderWidgetFeature::set_compositor_message_sender(
     scoped_ptr<BlimpMessageProcessor> message_processor) {
   DCHECK(message_processor);
   compositor_message_sender_ = std::move(message_processor);
 }
 
 void EngineRenderWidgetFeature::OnRenderWidgetCreated(
     const int tab_id,
     content::RenderWidgetHost* render_widget_host) {
   DCHECK(render_widget_host);
 
+  content::RenderViewHost* render_view_host =
+      content::RenderViewHost::From(render_widget_host);
+  if (render_view_host)
+    settings_feature_->UpdateWebkitPreferences(render_view_host);
+
   int render_widget_id = AddRenderWidget(tab_id, render_widget_host);
   DCHECK_GT(render_widget_id, 0);
 
   RenderWidgetMessage* render_widget_message;
   scoped_ptr<BlimpMessage> blimp_message =
       CreateBlimpMessage(&render_widget_message, tab_id);
   render_widget_message->set_type(RenderWidgetMessage::CREATED);
   render_widget_message->set_render_widget_id(render_widget_id);
 
   render_widget_message_sender_->ProcessMessage(std::move(blimp_message),
@@ skipping 107 matching lines @@
         delegate->OnCompositorMessageReceived(render_widget_host, payload);
       }
       break;
     default:
       NOTREACHED();
   }
 
   callback.Run(net::OK);
 }
 
+void EngineRenderWidgetFeature::OnWebPreferencesChanged() {
+  for (TabMap::iterator tab_it = tabs_.begin(); tab_it != tabs_.end();
+      tab_it++) {
+    RenderWidgetMaps render_widget_maps = tab_it->second;
+    RenderWidgetToIdMap render_widget_to_id = render_widget_maps.first;
+    for (RenderWidgetToIdMap::iterator it = render_widget_to_id.begin();
+        it != render_widget_to_id.end(); it++) {
+      content::RenderWidgetHost* render_widget_host = it->first;
+      content::RenderViewHost* render_view_host =
+          content::RenderViewHost::From(render_widget_host);
+      if (render_view_host)
+        settings_feature_->UpdateWebkitPreferences(render_view_host);
+    }
+  }
+}
+
 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;
 }
 
 int EngineRenderWidgetFeature::AddRenderWidget(
     const int tab_id,
@@ skipping 78 matching lines @@
 
   IdToRenderWidgetMap::const_iterator widget_id_it =
       id_to_render_widget->find(render_widget_id);
   if (widget_id_it == id_to_render_widget->end())
     return nullptr;
 
   return widget_id_it->second;
 }
 
 }  // namespace blimp