Replace image_messages.h with Mojo service

content/browser/frame_host/render_frame_host_impl.cc

 // Copyright 2013 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/browser/frame_host/render_frame_host_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 46 matching lines @@
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/isolated_world_ids.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
+#include "mojo/common/url_type_converters.h"
+#include "mojo/converters/geometry/geometry_type_converters.h"
+#include "skia/public/type_converters.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/accessibility/ax_tree.h"
 #include "ui/accessibility/ax_tree_update.h"
+#include "ui/gfx/geometry/size.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/mojo/service_registrar_android.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "content/browser/frame_host/popup_menu_helper_mac.h"
 #endif
 
@@ skipping 27 matching lines @@
     case blink::WebTextDirectionLeftToRight:
       return base::i18n::LEFT_TO_RIGHT;
     case blink::WebTextDirectionRightToLeft:
       return base::i18n::RIGHT_TO_LEFT;
     default:
       NOTREACHED();
       return base::i18n::UNKNOWN_DIRECTION;
   }
 }
 
+void DidDownloadImage(const WebContents::ImageDownloadCallback& callback,
+                      int id,
+                      const GURL& image_url,
+                      image_downloader::DownloadResultPtr result) {
+  DCHECK(result);
+
+  const std::vector<SkBitmap> images =
+      result->images.To<std::vector<SkBitmap>>();
+  const std::vector<gfx::Size> original_image_sizes =
+      result->original_image_sizes.To<std::vector<gfx::Size>>();
+
+  callback.Run(id, result->http_status_code, image_url, images,
+               original_image_sizes);
+}
+
 }  // namespace
 
 // static
 bool RenderFrameHostImpl::IsRFHStateActive(RenderFrameHostImplState rfh_state) {
   return rfh_state == STATE_DEFAULT;
 }
 
 // static
 RenderFrameHost* RenderFrameHost::FromID(int render_process_id,
                                          int render_frame_id) {
@@ skipping 1719 matching lines @@
 }
 
 void RenderFrameHostImpl::InvalidateMojoConnection() {
 #if defined(OS_ANDROID)
   // The Android-specific service registry has a reference to
   // |service_registry_| and thus must be torn down first.
   service_registry_android_.reset();
 #endif
 
   service_registry_.reset();
+
+  // Disconnect with ImageDownloader Mojo service in RenderFrame.
+  mojo_image_downloader_.reset();
 }
 
 bool RenderFrameHostImpl::IsFocused() {
   // TODO(mlamouri,kenrb): call GetRenderWidgetHost() directly when it stops
   // returning nullptr in some cases. See https://crbug.com/455245.
   return RenderWidgetHostImpl::From(
             GetView()->GetRenderWidgetHost())->is_focused() &&
          frame_tree_->GetFocusedFrame() &&
          (frame_tree_->GetFocusedFrame() == frame_tree_node() ||
           frame_tree_->GetFocusedFrame()->IsDescendantOf(frame_tree_node()));
 }
 
+int RenderFrameHostImpl::DownloadImage(

[nasko, 2015/07/02 08:41:07]

To avoid all the complexity of defining a callback in a common location, why not
allow access to the image download service by making it accessible from
RenderFrameHost? With that approach, the code of this method can be fully moved
to WebContentsImpl and there will be no layering violations.

[leonhsl(Using Gerrit), 2015/07/06 02:15:25]

Done.

+    const GURL& url,
+    bool is_favicon,
+    uint32_t max_bitmap_size,
+    bool bypass_cache,
+    const WebContents::ImageDownloadCallback& callback) {
+  static int next_image_download_id_ = 0;
+  image_downloader::DownloadRequestPtr req =
+      image_downloader::DownloadRequest::New();
+
+  if (!mojo_image_downloader_.get()) {
+    GetServiceRegistry()->ConnectToRemoteService(
+        mojo::GetProxy(&mojo_image_downloader_));

[nasko, 2015/07/02 08:41:07]

Can this fail? If not handled, this will cause a browser crash.

[Anand Mistry (off Chromium), 2015/07/02 08:56:51]

Not in a way that will cause a crash. This line will always succeed because the
connection is done asynchronously. If the connection ultimately fails (i.e. the
renderer crashes), then this will result in a hanging callback. But that problem
already exists in the current implementation.

+  }
+
+  req->url = mojo::String::From(url);
+  req->is_favicon = is_favicon;
+  req->max_bitmap_size = max_bitmap_size;
+  req->bypass_cache = bypass_cache;
+
+  mojo_image_downloader_->DownloadImage(
+      req.Pass(),
+      base::Bind(&DidDownloadImage, callback, ++next_image_download_id_, url));
+  return next_image_download_id_;
+}
+
 void RenderFrameHostImpl::UpdateCrossProcessIframeAccessibility(
     const std::map<int32, int>& node_to_frame_routing_id_map) {
   for (const auto& iter : node_to_frame_routing_id_map) {
     // This is the id of the accessibility node that has a child frame.
     int32 node_id = iter.first;
     // The routing id from either a RenderFrame or a RenderFrameProxy.
     int frame_routing_id = iter.second;
 
     FrameTree* frame_tree = frame_tree_node()->frame_tree();
     FrameTreeNode* child_frame_tree_node = frame_tree->FindByRoutingID(
@@ skipping 212 matching lines @@
   // We may be returning to an existing NavigationEntry that had been granted
   // file access.  If this is a different process, we will need to grant the
   // access again.  The files listed in the page state are validated when they
   // are received from the renderer to prevent abuse.
   if (request_params.page_state.IsValid()) {
     render_view_host_->GrantFileAccessFromPageState(request_params.page_state);
   }
 }
 
 }  // namespace content