Return operation name in prefetch request callback and add internal page hookup

components/offline_pages/core/prefetch/prefetch_request_operation_response_unittest.cc

 // Copyright 2017 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 "base/test/mock_callback.h"
 #include "components/offline_pages/core/prefetch/generate_page_bundle_request.h"
 #include "components/offline_pages/core/prefetch/get_operation_request.h"
 #include "components/offline_pages/core/prefetch/prefetch_proto_utils.h"
 #include "components/offline_pages/core/prefetch/prefetch_request_test_base.h"
 #include "components/offline_pages/core/prefetch/prefetch_types.h"
 #include "components/offline_pages/core/prefetch/proto/offline_pages.pb.h"
 #include "components/offline_pages/core/prefetch/proto/operation.pb.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/gurl.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Eq;
 using testing::SaveArg;
 
 namespace offline_pages {
 
 namespace {
 const version_info::Channel kTestChannel = version_info::Channel::UNKNOWN;
+const char kTestOperationName[] = "operation/test123";
 const char kTestURL[] = "http://example.com";
 const char kTestURL2[] = "http://example.com/2";
 const char kTestURL3[] = "http://example.com/3";
 const char kTestURL4[] = "http://example.com/4";
 const char kTestUserAgent[] = "Test User Agent";
 const char kTestGCMID[] = "Test GCM ID";
 const int kTestMaxBundleSize = 100000;
 const char kTestBodyName[] = "body_name";
 const int64_t kTestBodyLength = 12345678LL;
 const char kTestMethodName[] = "Test name";
@@ skipping 57 matching lines @@
 
  protected:
   // Helper function to build the operation based on |is_done| that controls
   // where Any value goes.
   std::string BuildOperation(bool is_done,
                              int error_code,
                              const std::string& error_message,
                              const std::string& any_type_url,
                              const std::string& any_value) {
     proto::Operation operation;
+    operation.set_name(kTestOperationName);
     operation.set_done(is_done);
     if (error_code != proto::OK) {
       operation.mutable_error()->set_code(error_code);
       operation.mutable_error()->set_message(error_message);
     }
     if (!any_type_url.empty()) {
       proto::Any* any =
           is_done ? operation.mutable_response() : operation.mutable_metadata();
       any->set_type_url(any_type_url);
       any->set_value(any_value);
@@ skipping 113 matching lines @@
   }
 
   PrefetchRequestStatus SendWithPageBundleResponse(
       const proto::PageBundle& bundle) {
     std::string bundle_data;
     EXPECT_TRUE(bundle.SerializeToString(&bundle_data));
     return SendWithResponse(
         builder_.BuildFromAny(kPageBundleTypeURL, bundle_data));
   }
 
+  const std::string& operation_name() const { return operation_name_; }
   const std::vector<RenderPageInfo>& pages() const { return pages_; }
 
  private:
   PrefetchRequestStatus SendWithResponse(const std::string& response_data) {
     base::MockCallback<PrefetchRequestFinishedCallback> callback;
     builder_.CreateRequest(request_context(), callback.Get());
 
     PrefetchRequestStatus status;
+    operation_name_.clear();
     pages_.clear();
-    EXPECT_CALL(callback, Run(_, _))
-        .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&pages_)));
+    EXPECT_CALL(callback, Run(_, _, _))
+        .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&operation_name_),
+                        SaveArg<2>(&pages_)));
     RespondWithData(response_data);
     return status;
   }
 
   T builder_;
+  std::string operation_name_;
   std::vector<RenderPageInfo> pages_;
 };
 
 // Lists all scenarios we want to test.
 typedef testing::Types<GeneratePageBundleRequestDoneOperationBuilder,
                        GeneratePageBundleRequestPendingOperationBuilder,
                        GetOperationRequestDoneOperationBuilder,
                        GetOperationRequestPendingOperationBuilder>
     MyTypes;
 TYPED_TEST_CASE(PrefetchRequestOperationResponseTest, MyTypes);
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, EmptyOperation) {
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             // No error is set for OK. Thus this will cause the operation
             // being filled with only done flag.
             this->SendWithErrorResponse(proto::OK, ""));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, ErrorValue) {
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             this->SendWithErrorResponse(proto::UNKNOWN, kErrorMessage));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, InvalidTypeUrl) {
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             this->SendWithAnyResponse("foo", ""));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, InvalidValue) {
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             this->SendWithAnyResponse(kPageBundleTypeURL, "foo"));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, EmptyPageBundle) {
   proto::PageBundle bundle;
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             this->SendWithPageBundleResponse(bundle));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, EmptyArchive) {
   proto::PageBundle bundle;
   bundle.add_archives();
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             this->SendWithPageBundleResponse(bundle));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, NoPageInfo) {
   proto::PageBundle bundle;
   proto::Archive* archive = bundle.add_archives();
   archive->set_body_name(kTestBodyName);
   archive->set_body_length(kTestBodyLength);
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             this->SendWithPageBundleResponse(bundle));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, MissingPageInfoUrl) {
   proto::PageBundle bundle;
   proto::Archive* archive = bundle.add_archives();
   proto::PageInfo* page_info = archive->add_page_infos();
   page_info->set_redirect_url(kTestURL);
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF,
             this->SendWithPageBundleResponse(bundle));
+  EXPECT_TRUE(this->operation_name().empty());
   EXPECT_TRUE(this->pages().empty());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, SinglePage) {
   proto::PageBundle bundle;
   proto::Archive* archive = bundle.add_archives();
   archive->set_body_name(kTestBodyName);
   archive->set_body_length(kTestBodyLength);
   proto::PageInfo* page_info = archive->add_page_infos();
   page_info->set_url(kTestURL);
   page_info->set_redirect_url(kTestURL2);
   page_info->mutable_status()->set_code(proto::OK);
   page_info->set_transformation(proto::NO_TRANSFORMATION);
   int64_t ms_since_epoch = base::Time::Now().ToJavaTime();
   page_info->mutable_render_time()->set_seconds(ms_since_epoch / 1000);
   page_info->mutable_render_time()->set_nanos((ms_since_epoch % 1000) *
                                               1000000);
   EXPECT_EQ(PrefetchRequestStatus::SUCCESS,
             this->SendWithPageBundleResponse(bundle));
+  EXPECT_EQ(kTestOperationName, this->operation_name());
   ASSERT_EQ(1u, this->pages().size());
   EXPECT_EQ(kTestURL, this->pages().back().url);
   EXPECT_EQ(kTestURL2, this->pages().back().redirect_url);
   EXPECT_EQ(RenderStatus::RENDERED, this->pages().back().status);
   EXPECT_EQ(kTestBodyName, this->pages().back().body_name);
   EXPECT_EQ(kTestBodyLength, this->pages().back().body_length);
   EXPECT_EQ(ms_since_epoch, this->pages().back().render_time.ToJavaTime());
 }
 
 TYPED_TEST(PrefetchRequestOperationResponseTest, MultiplePages) {
@@ skipping 25 matching lines @@
   page_info->set_url(kTestURL4);
   page_info->mutable_status()->set_code(proto::OK);
   page_info->set_transformation(proto::NO_TRANSFORMATION);
   int64_t ms_since_epoch = base::Time::Now().ToJavaTime();
   page_info->mutable_render_time()->set_seconds(ms_since_epoch / 1000);
   page_info->mutable_render_time()->set_nanos((ms_since_epoch % 1000) *
                                               1000000);
 
   EXPECT_EQ(PrefetchRequestStatus::SUCCESS,
             this->SendWithPageBundleResponse(bundle));
+  EXPECT_EQ(kTestOperationName, this->operation_name());
   ASSERT_EQ(4u, this->pages().size());
   EXPECT_EQ(kTestURL, this->pages().at(0).url);
   EXPECT_EQ(RenderStatus::PENDING, this->pages().at(0).status);
   EXPECT_EQ(kTestURL2, this->pages().at(1).url);
   EXPECT_EQ(RenderStatus::EXCEEDED_LIMIT, this->pages().at(1).status);
   EXPECT_EQ(kTestURL3, this->pages().at(2).url);
   EXPECT_EQ(RenderStatus::FAILED, this->pages().at(2).status);
   EXPECT_EQ(kTestURL4, this->pages().at(3).url);
   EXPECT_EQ(RenderStatus::RENDERED, this->pages().at(3).status);
   EXPECT_EQ(kTestBodyName, this->pages().at(3).body_name);
   EXPECT_EQ(kTestBodyLength, this->pages().at(3).body_length);
   EXPECT_EQ(ms_since_epoch, this->pages().at(3).render_time.ToJavaTime());
 }
 
 }  // namespace offline_pages