Using ResourceRequestBody as the type of HTTP body outside of //content.

content/public/common/resource_request_body.h

 // Copyright 2016 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 CONTENT_PUBLIC_COMMON_RESOURCE_REQUEST_BODY_H_
 #define CONTENT_PUBLIC_COMMON_RESOURCE_REQUEST_BODY_H_
 
 #include <stdint.h>
 
+#include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "build/build_config.h"
 #include "content/common/content_export.h"
 
+#if defined(OS_ANDROID)
+#include <jni.h>
+#include "base/android/scoped_java_ref.h"
+#endif
+
 namespace content {
 
 // ResourceRequestBody represents body (i.e. upload data) of a HTTP request.
 //
 // This class is intentionally opaque:
-// - Embedders cannot inspect the payload of ResourceRequestBody.  Only the
-//   //content layer can decompose ResourceRequestBody into references to file
-//   ranges, byte vectors, blob uris, etc.
-// - Embedders can get instances of ResourceRequestBody only by receiving an
-//   instance created inside //content layer (e.g. receiving it via
-//   content::OpenURLParams).
-// - Embedders typically end up passing ResourceRequestBody back into the
-//   //content layer via content::NavigationController::LoadUrlParams.
+// *) Embedders cannot inspect the payload of ResourceRequestBody.  Only the
+//    //content layer can decompose ResourceRequestBody into references to file
+//    ranges, byte vectors, blob uris, etc.
+// *) Embedders can get instances of ResourceRequestBody only by
+//    - receiving an instance created inside //content layer (e.g. receiving it
+//      via content::OpenURLParams),
+//    - calling CreateFromBytes with a vector of bytes (e.g. to support
+//      Android's WebView::postUrl API and to support test code).
+// *) Embedders typically end up passing ResourceRequestBody back into the
+//    //content layer via content::NavigationController::LoadUrlParams.
 class CONTENT_EXPORT ResourceRequestBody
     : public base::RefCountedThreadSafe<ResourceRequestBody> {
+ public:
+  // Creates ResourceRequestBody that holds a copy of |bytes|.
+  static scoped_refptr<ResourceRequestBody> CreateFromBytes(const char* bytes,

[Charlie Reis, 2016/06/09 22:38:16]

You mentioned that this should only be used for Android and for tests.  I've
found that unless we make that explicit, people add other call sites that we
didn't intend.

Maybe we can have a CreateFromBytesForTesting on all platforms and a
CreateFromBytes ifdef'd to Android?  Under the hood, they can use the same code,
but that would make people think twice before trying to use this in other ways.

[Łukasz Anforowicz, 2016/06/10 19:20:50]

I found out that I was wrong about that - there is one piece of non-Android
product code that also depends on content::ResourceRequestBody::CreateFromBytes.
 It is: chrome/browser/ui/tab_contents/core_tab_helper.cc:
CoreTabHelper::DoSearchByImageInNewTab.  I am not sure what this does, but it
seems that it posts image data to a search engine
(IDC_CONTENT_CONTEXT_SEARCHWEBFORIMAGE).
Given above, I don't think we can do this.

[Charlie Reis, 2016/06/10 20:59:28]

As Daniel points out, this is the "Search Google for image" context menu item
when you right click on images.
Ah, they beat me to it!  That's just the kind of thing I was afraid of-- using
an Android-specific API for new non-Android features, likely without a review of
the implications.  Ok, let's hope it's a sane use case, since now we have to
support it.

I suppose we could update the comment above to list that as another example,
though we don't really need to be exhaustive about how it's used.  (That would
just be a breadcrumb that it's used outside of Android and tests, so suggestions
like mine don't work.)

[Łukasz Anforowicz, 2016/06/13 18:01:11]

Oh, ok.  It seems to continue to work in the private build of Chrome with these
changes :-)
Done.

+                                                            size_t length);
+  static scoped_refptr<ResourceRequestBody> CreateFromBytes(
+      const std::string& bytes);

[Charlie Reis, 2016/06/09 22:38:16]

Maybe we can get by with just the first version of this?  Looks like there's
only about new 3 places that would have to call data() and size() when passing
it in.

(This is mainly useful to avoid having 4 methods if we go with my ForTesting
suggestion above.)

[Łukasz Anforowicz, 2016/06/10 19:20:50]

Done.

+
+#if defined(OS_ANDROID)
+  // Returns a org.chromium.content_public.common.ResourceRequestBody Java
+  // object that wraps a ref-counted pointer to the |resource_request_body|.
+  base::android::ScopedJavaLocalRef<jobject> ToJavaObject(JNIEnv* env);
+
+  // Extracts and returns a C++ object out of Java's
+  // org.chromium.content_public.common.ResourceRequestBody.
+  static scoped_refptr<ResourceRequestBody> FromJavaObject(
+      JNIEnv* env,
+      const base::android::JavaParamRef<jobject>& java_object);
+#endif
+
  protected:
   ResourceRequestBody();
   virtual ~ResourceRequestBody();
 
  private:
   friend class base::RefCountedThreadSafe<ResourceRequestBody>;
   DISALLOW_COPY_AND_ASSIGN(ResourceRequestBody);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_COMMON_RESOURCE_REQUEST_BODY_H_