rewrapped Rc<RefCell<Response>> into Rc<Response>

components/net/fetch/request.rs

@@ -296,39 +296,37 @@ fn http_fetch(request: Rc<Request>,
               authentication_fetch_flag: bool) -> Response {
 
     // Step 1
-    let mut response: Option<Rc<RefCell<Response>>> = None;
+    let mut response: Option<Rc<Response>> = None;
 
     // Step 2
-    let mut actual_response: Option<Rc<RefCell<Response>>> = None;
+    let mut actual_response: Option<Rc<Response>> = None;
 
     // Step 3
     if !request.skip_service_worker.get() && !request.is_service_worker_global_scope {
 
         // TODO: Substep 1 (handle fetch unimplemented)
         if let Some(ref res) = response {
-            let resp = res.borrow();
 
             // Substep 2
-            actual_response = match resp.internal_response {
+            actual_response = match res.internal_response {
                 Some(ref internal_res) => Some(internal_res.clone()),
                 None => Some(res.clone())
             };
 
             // Substep 3
-            if (resp.response_type == ResponseType::Opaque &&
+            if (res.response_type == ResponseType::Opaque &&
                 request.mode != RequestMode::NoCORS) ||
-               (resp.response_type == ResponseType::OpaqueRedirect &&
+               (res.response_type == ResponseType::OpaqueRedirect &&
                 request.redirect_mode != RedirectMode::Manual) ||
-               resp.response_type == ResponseType::Error {
+               res.response_type == ResponseType::Error {
                 return Response::network_error();
             }
         }
 
         // Substep 4
         if let Some(ref res) = actual_response {
-            let mut resp = res.borrow_mut();
-            if resp.url_list.is_empty() {
-                resp.url_list = request.url_list.borrow().clone();
+            if res.url_list.borrow().is_empty() {
+                *res.url_list.borrow_mut() = request.url_list.borrow().clone();
             }
         }
 
@@ -370,7 +368,7 @@ fn http_fetch(request: Rc<Request>,
                 if preflight_result.response_type == ResponseType::Error {
                     return Response::network_error();
                 }
-                response = Some(Rc::new(RefCell::new(preflight_result)));
+                response = Some(Rc::new(preflight_result));
             }
         }
 
@@ -394,13 +392,13 @@ fn http_fetch(request: Rc<Request>,
             return Response::network_error();
         }
 
-        response = Some(Rc::new(RefCell::new(fetch_result)));
+        response = Some(Rc::new(fetch_result));
         actual_response = response.clone();
     }
 
     // Step 5
-    let actual_response = Rc::try_unwrap(actual_response.unwrap()).ok().unwrap().into_inner();
-    let response = Rc::try_unwrap(response.unwrap()).ok().unwrap();
+    let actual_response = Rc::try_unwrap(actual_response.unwrap()).ok().unwrap();
+    let mut response = Rc::try_unwrap(response.unwrap()).ok().unwrap();
 
     match actual_response.status.unwrap() {
 
@@ -445,7 +443,7 @@ fn http_fetch(request: Rc<Request>,
 
                 // Step 9
                 RedirectMode::Manual => {
-                    *response.borrow_mut() = actual_response.to_filtered(ResponseType::Opaque);
+                    response = actual_response.to_filtered(ResponseType::Opaque);
                 }
 
                 // Step 10
@@ -495,7 +493,7 @@ fn http_fetch(request: Rc<Request>,
             // Step 1
             // FIXME: Figure out what to do with request window objects
             if cors_flag {
-                return response.into_inner();
+                return response;
             }
 
             // Step 2
@@ -531,8 +529,6 @@ fn http_fetch(request: Rc<Request>,
         _ => { }
     }
 
-    let response = response.into_inner();
-
     // Step 6
     if authentication_fetch_flag {
         // TODO: Create authentication entry for this request
@@ -793,7 +789,7 @@ fn http_network_fetch(request: Rc<Request>,
     };
 
     // Step 6
-    response.url_list = request.url_list.borrow().clone();
+    *response.url_list.borrow_mut() = request.url_list.borrow().clone();
 
     // Step 7
 

components/net/fetch/response.rs

@@ -22,7 +22,7 @@ impl ResponseMethods for Response {
             response_type: ResponseType::Default,
             termination_reason: None,
             url: None,
-            url_list: Vec::new(),
+            url_list: RefCell::new(Vec::new()),
             status: Some(StatusCode::Ok),
             headers: Headers::new(),
             body: ResponseBody::Empty,
@@ -42,7 +42,7 @@ impl ResponseMethods for Response {
         }
         let old_headers = self.headers.clone();
         let mut response = self.clone();
-        response.internal_response = Some(Rc::new(RefCell::new(self)));
+        response.internal_response = Some(Rc::new(self));
         match filter_type {
             ResponseType::Default | ResponseType::Error => unreachable!(),
             ResponseType::Basic => {

components/net_traits/response.rs

@@ -67,7 +67,7 @@ pub struct Response {
     pub response_type: ResponseType,
     pub termination_reason: Option<TerminationReason>,
     pub url: Option<Url>,
-    pub url_list: Vec<Url>,
+    pub url_list: RefCell<Vec<Url>>,
     /// `None` can be considered a StatusCode of `0`.
     pub status: Option<StatusCode>,
     pub headers: Headers,
@@ -76,7 +76,7 @@ pub struct Response {
     pub https_state: HttpsState,
     /// [Internal response](https://fetch.spec.whatwg.org/#concept-internal-response), only used if the Response
     /// is a filtered response
-    pub internal_response: Option<Rc<RefCell<Response>>>,
+    pub internal_response: Option<Rc<Response>>,
 }
 
 impl Response {
@@ -85,7 +85,7 @@ impl Response {
             response_type: ResponseType::Error,
             termination_reason: None,
             url: None,
-            url_list: vec![],
+            url_list: RefCell::new(vec![]),
             status: None,
             headers: Headers::new(),
             body: ResponseBody::Empty,