Move allocate instance id to chrome/.

chrome/browser/guest_view/guest_view_manager.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 "chrome/browser/guest_view/guest_view_manager.h"
 
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/guest_view/guest_view_base.h"
 #include "chrome/browser/guest_view/guest_view_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_system.h"
 #include "net/base/escape.h"
 #include "url/gurl.h"
 
 using content::BrowserContext;
 using content::SiteInstance;
 using content::WebContents;
 
+namespace {
+
+void ParsePartitionParam(const std::string& partition_str,
+                         std::string* storage_partition_id,
+                         bool* persist_storage) {
+  // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
+  // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
+  // remove the prefix without splicing in the middle of a multi-byte codepoint.
+  // We can use the rest of the string as UTF-8 encoded one.
+  if (StartsWithASCII(partition_str, "persist:", true)) {
+    size_t index = partition_str.find(":");
+    CHECK(index != std::string::npos);
+    // It is safe to do index + 1, since we tested for the full prefix above.
+    *storage_partition_id = partition_str.substr(index + 1);
+
+    if (storage_partition_id->empty()) {
+      // TODO(lazyboy): Better way to deal with this error.
+      return;
+    }
+    *persist_storage = true;
+  } else {
+    *storage_partition_id = partition_str;
+    *persist_storage = false;
+  }
+
+  printf("Output: storage_partition_id: %s, persist_storage: %d\n",
+         storage_partition_id->c_str(), *persist_storage);
+}
+
+}  // namespace
+
+
 // A WebContents does not immediately have a RenderProcessHost. It acquires one
 // on initial navigation. This observer exists until that initial navigation in
 // order to grab the ID if tis RenderProcessHost so that it can register it as
 // a guest.
 class GuestWebContentsObserver
     : public content::WebContentsObserver {
  public:
   explicit GuestWebContentsObserver(WebContents* guest_web_contents)
       : WebContentsObserver(guest_web_contents) {
   }
@@ skipping 49 matching lines @@
                                             guest_instance_id)) {
     return NULL;
   }
   return GetGuestByInstanceID(guest_instance_id, embedder_render_process_id);
 }
 
 int GuestViewManager::GetNextInstanceID() {
   return ++current_instance_id_;
 }
 
 content::WebContents* GuestViewManager::CreateGuest(

[Fady Samuel, 2014/05/27 14:19:06]

I'd like to chat about this method. I want to make it sufficiently general so
that it also works for <appview>. Ideally, what we would have is one method that
can create any type of guest.

Maybe we can determine what to do based on the extra params?

[lazyboy, 2014/05/27 20:43:00]

OK.
We can do this in future CLs.

     content::SiteInstance* embedder_site_instance,
     int instance_id,
-    const std::string& storage_partition_id,
-    bool persist_storage,
     scoped_ptr<base::DictionaryValue> extra_params) {
+  std::string storage_partition_id;
+  bool persist_storage = false;
+  std::string storage_partition_string;
+  if (extra_params->GetString(guestview::kStoragePartitionId,
+                              &storage_partition_string)) {
+    ParsePartitionParam(
+        storage_partition_string, &storage_partition_id, &persist_storage);
+  } else {
+    printf("Not found storagePartitionId key\n");
+  }
+
   content::RenderProcessHost* embedder_process_host =
       embedder_site_instance->GetProcess();
   // Validate that the partition id coming from the renderer is valid UTF-8,
   // since we depend on this in other parts of the code, such as FilePath
   // creation. If the validation fails, treat it as a bad message and kill the
   // renderer process.
   if (!base::IsStringUTF8(storage_partition_id)) {
     content::RecordAction(
         base::UserMetricsAction("BadMessageTerminate_BPGM"));
     base::KillProcess(
@@ skipping 191 matching lines @@
       return false;
 
     return embedder_render_process_id ==
         guest->GetOpener()->embedder_web_contents()->GetRenderProcessHost()->
             GetID();
   }
 
   return embedder_render_process_id ==
       guest->embedder_web_contents()->GetRenderProcessHost()->GetID();
 }