Have the RequestCoordinator generate the offline_id

chrome/browser/android/offline_pages/prerendering_offliner.cc

 // 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.
 
 #include "chrome/browser/android/offline_pages/prerendering_offliner.h"
 
 #include "base/bind.h"
 #include "base/sys_info.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "components/offline_pages/background/save_page_request.h"
@@ skipping 43 matching lines @@
     // WebContents are being destroyed) - whichever callback occurs first.
     DCHECK(web_contents);
     std::unique_ptr<OfflinePageArchiver> archiver(
         new OfflinePageMHTMLArchiver(web_contents));
     // Pass in the URL from the WebContents in case it is redirected from
     // the requested URL. This is to work around a check in the
     // OfflinePageModel implementation that ensures URL passed in here is
     // same as LastCommittedURL from the snapshot.
     // TODO(dougarnett): Raise issue of how to better deal with redirects.
     SavePage(web_contents->GetLastCommittedURL(), request.client_id(),
-             std::move(archiver),
+             request.request_id(), std::move(archiver),
              base::Bind(&PrerenderingOffliner::OnSavePageDone,
                         weak_ptr_factory_.GetWeakPtr(), request));
   } else {
     // Clear pending request and app listener then run completion callback.
     pending_request_.reset(nullptr);
     app_listener_.reset(nullptr);
     completion_callback_.Run(request, load_status);
   }
 }
 
@@ skipping 89 matching lines @@
 }
 
 void PrerenderingOffliner::SetApplicationStateForTesting(
     base::android::ApplicationState application_state) {
   OnApplicationStateChange(application_state);
 }
 
 void PrerenderingOffliner::SavePage(
     const GURL& url,
     const ClientId& client_id,
+    int64_t proposed_offline_id,
     std::unique_ptr<OfflinePageArchiver> archiver,
     const SavePageCallback& save_callback) {
   DCHECK(offline_page_model_);
-  offline_page_model_->SavePage(url, client_id, std::move(archiver),
-                                save_callback);
+  offline_page_model_->SavePage(url, client_id, proposed_offline_id,
+                                std::move(archiver), save_callback);
 }
 
 PrerenderingLoader* PrerenderingOffliner::GetOrCreateLoader() {
   if (!loader_) {
     loader_.reset(new PrerenderingLoader(browser_context_));
   }
   return loader_.get();
 }
 
 void PrerenderingOffliner::OnApplicationStateChange(
     base::android::ApplicationState application_state) {
   if (pending_request_ && is_low_end_device_ &&
       application_state ==
           base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES) {
     DVLOG(1) << "App became active, canceling current offlining request";
     SavePageRequest* request = pending_request_.get();
     Cancel();
     completion_callback_.Run(*request,
                              Offliner::RequestStatus::FOREGROUND_CANCELED);
   }
 }
 
 }  // namespace offline_pages