OOP PDF: Override printing for MimeHandlerViewContainers.

extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.cc

 // Copyright 2014 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 "extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.h"
 
+#include <map>
+#include <set>
+
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
+#include "content/public/renderer/v8_value_converter.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/guest_view/guest_view_constants.h"
 #include "gin/arguments.h"
 #include "gin/dictionary.h"
 #include "gin/handle.h"
 #include "gin/interceptor.h"
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ skipping 44 matching lines @@
     return gin::Wrappable<ScriptableObject>::GetObjectTemplateBuilder(isolate)
         .AddNamedPropertyInterceptor();
   }
 
   base::WeakPtr<MimeHandlerViewContainer> container_;
 };
 
 // static
 gin::WrapperInfo ScriptableObject::kWrapperInfo = { gin::kEmbedderNativeGin };
 
+base::LazyInstance<

[raymes, 2015/01/22 00:58:57]

Please add a comment about what this tracks

[Sam McNally, 2015/01/22 03:23:29]

Done.

+    std::map<content::RenderFrame*, std::set<MimeHandlerViewContainer*>>>
+    g_mime_handler_view_container_map = LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 MimeHandlerViewContainer::MimeHandlerViewContainer(
     content::RenderFrame* render_frame,
     const std::string& mime_type,
     const GURL& original_url)
     : GuestViewContainer(render_frame),
       mime_type_(mime_type),
       original_url_(original_url),
       guest_proxy_routing_id_(-1),
       guest_loaded_(false),
       weak_factory_(this) {
   DCHECK(!mime_type_.empty());
   is_embedded_ = !render_frame->GetWebFrame()->document().isPluginDocument();
+  g_mime_handler_view_container_map.Get()[render_frame].insert(this);
 }
 
 MimeHandlerViewContainer::~MimeHandlerViewContainer() {
   if (loader_)
     loader_->cancel();
+
+  g_mime_handler_view_container_map.Get()[render_frame()].erase(this);
+  if (g_mime_handler_view_container_map.Get()[render_frame()].empty())
+    g_mime_handler_view_container_map.Get().erase(render_frame());
+}
+
+// static
+std::vector<MimeHandlerViewContainer*>
+MimeHandlerViewContainer::FromRenderFrame(content::RenderFrame* render_frame) {
+  auto it = g_mime_handler_view_container_map.Get().find(render_frame);
+  if (it == g_mime_handler_view_container_map.Get().end())
+    return std::vector<MimeHandlerViewContainer*>();
+
+  return std::vector<MimeHandlerViewContainer*>(it->second.begin(),
+                                                it->second.end());
 }
 
 void MimeHandlerViewContainer::Ready() {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   blink::WebURLLoaderOptions options;
   // The embedded plugin is allowed to be cross-origin.
   options.crossOriginRequestPolicy =
       blink::WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
   DCHECK(!loader_);
   loader_.reset(frame->createAssociatedURLLoader(options));
@@ skipping 82 matching lines @@
     // should already know what is embedded.
     gin::StringToV8(isolate, "*")
   };
   guest_proxy_frame->callFunctionEvenIfScriptDisabled(
       post_message.As<v8::Function>(),
       guest_proxy_window,
       arraysize(args),
       args);
 }
 
+void MimeHandlerViewContainer::PostMessageFromValue(
+    const base::Value& message) {
+  blink::WebFrame* frame = render_frame()->GetWebFrame();
+  if (!frame)
+    return;
+
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
+  v8::Context::Scope context_scope(frame->mainWorldScriptContext());
+  scoped_ptr<content::V8ValueConverter> converter(
+      content::V8ValueConverter::create());
+  PostMessage(isolate,
+              converter->ToV8Value(&message, frame->mainWorldScriptContext()));

[raymes, 2015/01/22 00:58:57]

nit: maybe make this a function (and reuse it in
OnMimeHandlerViewGuestOnLoadCompleted)

+}
+
 void MimeHandlerViewContainer::OnCreateMimeHandlerViewGuestACK(
     int element_instance_id) {
   DCHECK_NE(this->element_instance_id(), guestview::kInstanceIDNone);
   DCHECK_EQ(this->element_instance_id(), element_instance_id);
   render_frame()->AttachGuest(element_instance_id);
 }
 
 void MimeHandlerViewContainer::OnGuestAttached(int /* unused */,
                                                int guest_proxy_routing_id) {
   // Save the RenderView routing ID of the guest here so it can be used to route
@@ skipping 24 matching lines @@
 void MimeHandlerViewContainer::CreateMimeHandlerViewGuest() {
   // The loader has completed loading |view_id_| so we can dispose it.
   loader_.reset();
 
   DCHECK_NE(element_instance_id(), guestview::kInstanceIDNone);
   render_frame()->Send(new ExtensionHostMsg_CreateMimeHandlerViewGuest(
       render_frame()->GetRoutingID(), view_id_, element_instance_id()));
 }
 
 }  // namespace extensions