Change Lo-Fi bool to bitmask to support multiple Previews types

content/browser/loader/intercepting_resource_handler_unittest.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 "content/browser/loader/intercepting_resource_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/loader/resource_controller.h"
 #include "content/browser/loader/test_resource_handler.h"
 #include "content/public/browser/resource_request_info.h"
+#include "content/public/common/previews_state.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 34 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   TestResourceHandler* old_test_handler = old_handler.get();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
@@ skipping 48 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
@@ skipping 64 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler_scoped(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   // When sending a payload to the old ResourceHandler, the
   // InterceptingResourceHandler doesn't send a final EOF read.
   // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
   // entirely?
   old_handler_scoped->set_expect_eof_read(false);
@@ skipping 75 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   old_handler->set_on_will_read_result(false);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
@@ skipping 17 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
@@ skipping 34 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
@@ skipping 33 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
@@ skipping 42 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
@@ skipping 42 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   std::unique_ptr<TestResourceController> resource_controller =
       base::MakeUnique<TestResourceController>();
   net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   // When sending a payload to the old ResourceHandler, the
   // InterceptingResourceHandler doesn't send a final EOF read.
@@ skipping 108 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   std::unique_ptr<TestResourceController> resource_controller =
       base::MakeUnique<TestResourceController>();
   net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
 
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
@@ skipping 19 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   std::unique_ptr<TestResourceController> resource_controller =
       base::MakeUnique<TestResourceController>();
   net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   // When sending a payload to the old ResourceHandler, the
   // InterceptingResourceHandler doesn't send a final EOF read.
@@ skipping 58 matching lines @@
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
-                                          false);   // is_using_lofi
+                                          PREVIEWS_OFF);  // previews_state
 
   std::unique_ptr<TestResourceController> resource_controller =
       base::MakeUnique<TestResourceController>();
   net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
   old_handler->set_defer_on_read_completed(true);
 
@@ skipping 40 matching lines @@
       {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
   ASSERT_TRUE(defer);
   EXPECT_EQ(0, resource_controller->resume_calls());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
 }
 
 }  // namespace
 
 }  // namespace content