1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
// // DO NOT EDIT. THIS FILE IS GENERATED FROM ../../../dist/idl/nsIWebProgressListener.idl // /// `interface nsIWebProgressListener : nsISupports` /// /// ```text /// /** /// * The nsIWebProgressListener interface is implemented by clients wishing to /// * listen in on the progress associated with the loading of asynchronous /// * requests in the context of a nsIWebProgress instance as well as any child /// * nsIWebProgress instances. nsIWebProgress.idl describes the parent-child /// * relationship of nsIWebProgress instances. /// */ /// ``` /// // The actual type definition for the interface. This struct has methods // declared on it which will call through its vtable. You never want to pass // this type around by value, always pass it behind a reference. #[repr(C)] pub struct nsIWebProgressListener { vtable: *const nsIWebProgressListenerVTable, /// This field is a phantomdata to ensure that the VTable type and any /// struct containing it is not safe to send across threads, as XPCOM is /// generally not threadsafe. /// /// XPCOM interfaces in general are not safe to send across threads. __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>, } // Implementing XpCom for an interface exposes its IID, which allows for easy // use of the `.query_interface<T>` helper method. This also defines that // method for nsIWebProgressListener. unsafe impl XpCom for nsIWebProgressListener { const IID: nsIID = nsID(0xa9df523b, 0xefe2, 0x421e, [0x9d, 0x8e, 0x3d, 0x7f, 0x80, 0x7d, 0xda, 0x4c]); } // We need to implement the RefCounted trait so we can be used with `RefPtr`. // This trait teaches `RefPtr` how to manage our memory. unsafe impl RefCounted for nsIWebProgressListener { #[inline] unsafe fn addref(&self) { self.AddRef(); } #[inline] unsafe fn release(&self) { self.Release(); } } // This trait is implemented on all types which can be coerced to from nsIWebProgressListener. // It is used in the implementation of `fn coerce<T>`. We hide it from the // documentation, because it clutters it up a lot. #[doc(hidden)] pub trait nsIWebProgressListenerCoerce { /// Cheaply cast a value of this type from a `nsIWebProgressListener`. fn coerce_from(v: &nsIWebProgressListener) -> &Self; } // The trivial implementation: We can obviously coerce ourselves to ourselves. impl nsIWebProgressListenerCoerce for nsIWebProgressListener { #[inline] fn coerce_from(v: &nsIWebProgressListener) -> &Self { v } } impl nsIWebProgressListener { /// Cast this `nsIWebProgressListener` to one of its base interfaces. #[inline] pub fn coerce<T: nsIWebProgressListenerCoerce>(&self) -> &T { T::coerce_from(self) } } // Every interface struct type implements `Deref` to its base interface. This // causes methods on the base interfaces to be directly avaliable on the // object. For example, you can call `.AddRef` or `.QueryInterface` directly // on any interface which inherits from `nsISupports`. impl ::std::ops::Deref for nsIWebProgressListener { type Target = nsISupports; #[inline] fn deref(&self) -> &nsISupports { unsafe { ::std::mem::transmute(self) } } } // Ensure we can use .coerce() to cast to our base types as well. Any type which // our base interface can coerce from should be coercable from us as well. impl<T: nsISupportsCoerce> nsIWebProgressListenerCoerce for T { #[inline] fn coerce_from(v: &nsIWebProgressListener) -> &Self { T::coerce_from(v) } } // This struct represents the interface's VTable. A pointer to a statically // allocated version of this struct is at the beginning of every nsIWebProgressListener // object. It contains one pointer field for each method in the interface. In // the case where we can't generate a binding for a method, we include a void // pointer. #[doc(hidden)] #[repr(C)] pub struct nsIWebProgressListenerVTable { /// We need to include the members from the base interface's vtable at the start /// of the VTable definition. pub __base: nsISupportsVTable, /* void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aStateFlags, in nsresult aStatus); */ pub OnStateChange: unsafe extern "system" fn (this: *const nsIWebProgressListener, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aStateFlags: libc::uint32_t, aStatus: nsresult) -> nsresult, /* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */ pub OnProgressChange: unsafe extern "system" fn (this: *const nsIWebProgressListener, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aCurSelfProgress: libc::int32_t, aMaxSelfProgress: libc::int32_t, aCurTotalProgress: libc::int32_t, aMaxTotalProgress: libc::int32_t) -> nsresult, /* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI aLocation, [optional] in unsigned long aFlags); */ pub OnLocationChange: unsafe extern "system" fn (this: *const nsIWebProgressListener, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aLocation: *const nsIURI, aFlags: libc::uint32_t) -> nsresult, /* void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage); */ pub OnStatusChange: unsafe extern "system" fn (this: *const nsIWebProgressListener, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aStatus: nsresult, aMessage: *const libc::int16_t) -> nsresult, /* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aState); */ pub OnSecurityChange: unsafe extern "system" fn (this: *const nsIWebProgressListener, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aState: libc::uint32_t) -> nsresult, } // The implementations of the function wrappers which are exposed to rust code. // Call these methods rather than manually calling through the VTable struct. impl nsIWebProgressListener { /// ```text /// /** /// * State Transition Flags /// * /// * These flags indicate the various states that requests may transition /// * through as they are being loaded. These flags are mutually exclusive. /// * /// * For any given request, onStateChange is called once with the STATE_START /// * flag, zero or more times with the STATE_TRANSFERRING flag or once with the /// * STATE_REDIRECTING flag, and then finally once with the STATE_STOP flag. /// * NOTE: For document requests, a second STATE_STOP is generated (see the /// * description of STATE_IS_WINDOW for more details). /// * /// * STATE_START /// * This flag indicates the start of a request. This flag is set when a /// * request is initiated. The request is complete when onStateChange is /// * called for the same request with the STATE_STOP flag set. /// * /// * STATE_REDIRECTING /// * This flag indicates that a request is being redirected. The request /// * passed to onStateChange is the request that is being redirected. When a /// * redirect occurs, a new request is generated automatically to process the /// * new request. Expect a corresponding STATE_START event for the new /// * request, and a STATE_STOP for the redirected request. /// * /// * STATE_TRANSFERRING /// * This flag indicates that data for a request is being transferred to an /// * end consumer. This flag indicates that the request has been targeted, /// * and that the user may start seeing content corresponding to the request. /// * /// * STATE_NEGOTIATING /// * This flag is not used. /// * /// * STATE_STOP /// * This flag indicates the completion of a request. The aStatus parameter /// * to onStateChange indicates the final status of the request. /// */ /// ``` /// pub const STATE_START: i64 = 1; pub const STATE_REDIRECTING: i64 = 2; pub const STATE_TRANSFERRING: i64 = 4; pub const STATE_NEGOTIATING: i64 = 8; pub const STATE_STOP: i64 = 16; /// ```text /// /** /// * State Type Flags /// * /// * These flags further describe the entity for which the state transition is /// * occuring. These flags are NOT mutually exclusive (i.e., an onStateChange /// * event may indicate some combination of these flags). /// * /// * STATE_IS_REQUEST /// * This flag indicates that the state transition is for a request, which /// * includes but is not limited to document requests. (See below for a /// * description of document requests.) Other types of requests, such as /// * requests for inline content (e.g., images and stylesheets) are /// * considered normal requests. /// * /// * STATE_IS_DOCUMENT /// * This flag indicates that the state transition is for a document request. /// * This flag is set in addition to STATE_IS_REQUEST. A document request /// * supports the nsIChannel interface and its loadFlags attribute includes /// * the nsIChannel::LOAD_DOCUMENT_URI flag. /// * /// * A document request does not complete until all requests associated with /// * the loading of its corresponding document have completed. This includes /// * other document requests (e.g., corresponding to HTML <iframe> elements). /// * The document corresponding to a document request is available via the /// * DOMWindow attribute of onStateChange's aWebProgress parameter. /// * /// * STATE_IS_NETWORK /// * This flag indicates that the state transition corresponds to the start /// * or stop of activity in the indicated nsIWebProgress instance. This flag /// * is accompanied by either STATE_START or STATE_STOP, and it may be /// * combined with other State Type Flags. /// * /// * Unlike STATE_IS_WINDOW, this flag is only set when activity within the /// * nsIWebProgress instance being observed starts or stops. If activity /// * only occurs in a child nsIWebProgress instance, then this flag will be /// * set to indicate the start and stop of that activity. /// * /// * For example, in the case of navigation within a single frame of a HTML /// * frameset, a nsIWebProgressListener instance attached to the /// * nsIWebProgress of the frameset window will receive onStateChange calls /// * with the STATE_IS_NETWORK flag set to indicate the start and stop of /// * said navigation. In other words, an observer of an outer window can /// * determine when activity, that may be constrained to a child window or /// * set of child windows, starts and stops. /// * /// * STATE_IS_WINDOW /// * This flag indicates that the state transition corresponds to the start /// * or stop of activity in the indicated nsIWebProgress instance. This flag /// * is accompanied by either STATE_START or STATE_STOP, and it may be /// * combined with other State Type Flags. /// * /// * This flag is similar to STATE_IS_DOCUMENT. However, when a document /// * request completes, two onStateChange calls with STATE_STOP are /// * generated. The document request is passed as aRequest to both calls. /// * The first has STATE_IS_REQUEST and STATE_IS_DOCUMENT set, and the second /// * has the STATE_IS_WINDOW flag set (and possibly the STATE_IS_NETWORK flag /// * set as well -- see above for a description of when the STATE_IS_NETWORK /// * flag may be set). This second STATE_STOP event may be useful as a way /// * to partition the work that occurs when a document request completes. /// * /// * STATE_IS_REDIRECTED_DOCUMENT /// * Same as STATE_IS_DOCUMENT, but sent only after a redirect has occured. /// * Introduced in order not to confuse existing code with extra state change /// * events. See |nsDocLoader::OnStartRequest| for more info. /// */ /// ``` /// pub const STATE_IS_REQUEST: i64 = 65536; pub const STATE_IS_DOCUMENT: i64 = 131072; pub const STATE_IS_NETWORK: i64 = 262144; pub const STATE_IS_WINDOW: i64 = 524288; pub const STATE_IS_REDIRECTED_DOCUMENT: i64 = 1048576; /// ```text /// /** /// * State Modifier Flags /// * /// * These flags further describe the transition which is occuring. These /// * flags are NOT mutually exclusive (i.e., an onStateChange event may /// * indicate some combination of these flags). /// * /// * STATE_RESTORING /// * This flag indicates that the state transition corresponds to the start /// * or stop of activity for restoring a previously-rendered presentation. /// * As such, there is no actual network activity associated with this /// * request, and any modifications made to the document or presentation /// * when it was originally loaded will still be present. /// */ /// ``` /// pub const STATE_RESTORING: i64 = 16777216; /// ```text /// /** /// * State Security Flags /// * /// * These flags describe the security state reported by a call to the /// * onSecurityChange method. These flags are mutually exclusive. /// * /// * STATE_IS_INSECURE /// * This flag indicates that the data corresponding to the request /// * was received over an insecure channel. /// * /// * STATE_IS_BROKEN /// * This flag indicates an unknown security state. This may mean that the /// * request is being loaded as part of a page in which some content was /// * received over an insecure channel. /// * /// * STATE_IS_SECURE /// * This flag indicates that the data corresponding to the request was /// * received over a secure channel. The degree of security is expressed by /// * STATE_SECURE_HIGH, STATE_SECURE_MED, or STATE_SECURE_LOW. /// */ /// ``` /// pub const STATE_IS_INSECURE: i64 = 4; pub const STATE_IS_BROKEN: i64 = 1; pub const STATE_IS_SECURE: i64 = 2; /// ```text /// /** /// * Mixed active content flags /// * /// * May be set in addition to the State Security Flags, to indicate that /// * mixed active content has been encountered. /// * /// * STATE_BLOCKED_MIXED_ACTIVE_CONTENT /// * Mixed active content has been blocked from loading. /// * /// * STATE_LOADED_MIXED_ACTIVE_CONTENT /// * Mixed active content has been loaded. State should be STATE_IS_BROKEN. /// */ /// ``` /// pub const STATE_BLOCKED_MIXED_ACTIVE_CONTENT: i64 = 16; pub const STATE_LOADED_MIXED_ACTIVE_CONTENT: i64 = 32; /// ```text /// /** /// * Mixed display content flags /// * /// * May be set in addition to the State Security Flags, to indicate that /// * mixed display content has been encountered. /// * /// * STATE_BLOCKED_MIXED_DISPLAY_CONTENT /// * Mixed display content has been blocked from loading. /// * /// * STATE_LOADED_MIXED_DISPLAY_CONTENT /// * Mixed display content has been loaded. State should be STATE_IS_BROKEN. /// */ /// ``` /// pub const STATE_BLOCKED_MIXED_DISPLAY_CONTENT: i64 = 256; pub const STATE_LOADED_MIXED_DISPLAY_CONTENT: i64 = 512; /// ```text /// /** /// * Safe Browsing blocking content flags /// * /// * May be set in addition to the State security Flags, to indicate that /// * tracking or unsafe content has been encountered. /// * /// * STATE_BLOCKED_TRACKING_CONTENT /// * Tracking content has been blocked from loading. /// * /// * STATE_LOADED_TRACKING_CONTENT /// * Tracking content has been loaded. /// * /// * STATE_BLOCKED_UNSAFE_CONTENT /// * Content which againts SafeBrowsing list has been blocked from loading. /// */ /// ``` /// pub const STATE_BLOCKED_TRACKING_CONTENT: i64 = 4096; pub const STATE_LOADED_TRACKING_CONTENT: i64 = 8192; pub const STATE_BLOCKED_UNSAFE_CONTENT: i64 = 16384; /// ```text /// /** /// * Diagnostic flags /// * /// * May be set in addition to other security state flags to indicate that /// * some state is countered that deserves a warning or error, but does not /// * change the top level security state of the connection. /// * /// * STATE_CERT_DISTRUST_IMMINENT /// * The certificate in use will be distrusted in the near future. /// */ /// ``` /// pub const STATE_CERT_DISTRUST_IMMINENT: i64 = 32768; /// ```text /// /** /// * Security Strength Flags /// * /// * These flags describe the security strength and accompany STATE_IS_SECURE /// * in a call to the onSecurityChange method. These flags are mutually /// * exclusive. /// * /// * These flags are not meant to provide a precise description of data /// * transfer security. These are instead intended as a rough indicator that /// * may be used to, for example, color code a security indicator or otherwise /// * provide basic data transfer security feedback to the user. /// * /// * STATE_SECURE_HIGH /// * This flag indicates a high degree of security. /// * /// * STATE_SECURE_MED /// * This flag indicates a medium degree of security. /// * /// * STATE_SECURE_LOW /// * This flag indicates a low degree of security. /// */ /// ``` /// pub const STATE_SECURE_HIGH: i64 = 262144; pub const STATE_SECURE_MED: i64 = 65536; pub const STATE_SECURE_LOW: i64 = 131072; /// ```text /// /** /// * State bits for EV == Extended Validation == High Assurance /// * /// * These flags describe the level of identity verification /// * in a call to the onSecurityChange method. /// * /// * STATE_IDENTITY_EV_TOPLEVEL /// * The topmost document uses an EV cert. /// * NOTE: Available since Gecko 1.9 /// */ /// ``` /// pub const STATE_IDENTITY_EV_TOPLEVEL: i64 = 1048576; /// ```text /// /** /// * Broken state flags /// * /// * These flags describe the reason of the broken state. /// * /// * STATE_USES_SSL_3 /// * The topmost document uses SSL 3.0. /// * /// * STATE_USES_WEAK_CRYPTO /// * The topmost document uses a weak cipher suite such as RC4. /// * /// * STATE_CERT_USER_OVERRIDDEN /// * The user has added a security exception for the site. /// */ /// ``` /// pub const STATE_USES_SSL_3: i64 = 16777216; pub const STATE_USES_WEAK_CRYPTO: i64 = 33554432; pub const STATE_CERT_USER_OVERRIDDEN: i64 = 67108864; /// ```text /// /** /// * Flags for onLocationChange /// * /// * LOCATION_CHANGE_SAME_DOCUMENT /// * This flag is on when |aWebProgress| did not load a new document. /// * For example, the location change is due to an anchor scroll or a /// * pushState/popState/replaceState. /// * /// * LOCATION_CHANGE_ERROR_PAGE /// * This flag is on when |aWebProgress| redirected from the requested /// * contents to an internal page to show error status, such as /// * <about:neterror>, <about:certerror> and so on. /// * /// * Generally speaking, |aURI| and |aRequest| are the original data. DOM /// * |window.location.href| is also the original location, while /// * |document.documentURI| is the redirected location. Sometimes |aURI| is /// * <about:blank> and |aRequest| is null when the original data does not /// + remain. /// * /// * |aWebProgress| does NOT set this flag when it did not try to load a new /// * document. In this case, it should set LOCATION_CHANGE_SAME_DOCUMENT. /// */ /// ``` /// pub const LOCATION_CHANGE_SAME_DOCUMENT: i64 = 1; pub const LOCATION_CHANGE_ERROR_PAGE: i64 = 2; /// ```text /// /** /// * Notification indicating the state has changed for one of the requests /// * associated with aWebProgress. /// * /// * @param aWebProgress /// * The nsIWebProgress instance that fired the notification /// * @param aRequest /// * The nsIRequest that has changed state. /// * @param aStateFlags /// * Flags indicating the new state. This value is a combination of one /// * of the State Transition Flags and one or more of the State Type /// * Flags defined above. Any undefined bits are reserved for future /// * use. /// * @param aStatus /// * Error status code associated with the state change. This parameter /// * should be ignored unless aStateFlags includes the STATE_STOP bit. /// * The status code indicates success or failure of the request /// * associated with the state change. NOTE: aStatus may be a success /// * code even for server generated errors, such as the HTTP 404 error. /// * In such cases, the request itself should be queried for extended /// * error information (e.g., for HTTP requests see nsIHttpChannel). /// */ /// ``` /// /// `void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aStateFlags, in nsresult aStatus);` #[inline] pub unsafe fn OnStateChange(&self, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aStateFlags: libc::uint32_t, aStatus: nsresult) -> nsresult { ((*self.vtable).OnStateChange)(self, aWebProgress, aRequest, aStateFlags, aStatus) } /// ```text /// /** /// * Notification that the progress has changed for one of the requests /// * associated with aWebProgress. Progress totals are reset to zero when all /// * requests in aWebProgress complete (corresponding to onStateChange being /// * called with aStateFlags including the STATE_STOP and STATE_IS_WINDOW /// * flags). /// * /// * @param aWebProgress /// * The nsIWebProgress instance that fired the notification. /// * @param aRequest /// * The nsIRequest that has new progress. /// * @param aCurSelfProgress /// * The current progress for aRequest. /// * @param aMaxSelfProgress /// * The maximum progress for aRequest. /// * @param aCurTotalProgress /// * The current progress for all requests associated with aWebProgress. /// * @param aMaxTotalProgress /// * The total progress for all requests associated with aWebProgress. /// * /// * NOTE: If any progress value is unknown, or if its value would exceed the /// * maximum value of type long, then its value is replaced with -1. /// * /// * NOTE: If the object also implements nsIWebProgressListener2 and the caller /// * knows about that interface, this function will not be called. Instead, /// * nsIWebProgressListener2::onProgressChange64 will be called. /// */ /// ``` /// /// `void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress);` #[inline] pub unsafe fn OnProgressChange(&self, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aCurSelfProgress: libc::int32_t, aMaxSelfProgress: libc::int32_t, aCurTotalProgress: libc::int32_t, aMaxTotalProgress: libc::int32_t) -> nsresult { ((*self.vtable).OnProgressChange)(self, aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress) } /// ```text /// /** /// * Called when the location of the window being watched changes. This is not /// * when a load is requested, but rather once it is verified that the load is /// * going to occur in the given window. For instance, a load that starts in a /// * window might send progress and status messages for the new site, but it /// * will not send the onLocationChange until we are sure that we are loading /// * this new page here. /// * /// * @param aWebProgress /// * The nsIWebProgress instance that fired the notification. /// * @param aRequest /// * The associated nsIRequest. This may be null in some cases. /// * @param aLocation /// * The URI of the location that is being loaded. /// * @param aFlags /// * This is a value which explains the situation or the reason why /// * the location has changed. /// */ /// ``` /// /// `void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI aLocation, [optional] in unsigned long aFlags);` #[inline] pub unsafe fn OnLocationChange(&self, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aLocation: *const nsIURI, aFlags: libc::uint32_t) -> nsresult { ((*self.vtable).OnLocationChange)(self, aWebProgress, aRequest, aLocation, aFlags) } /// ```text /// /** /// * Notification that the status of a request has changed. The status message /// * is intended to be displayed to the user (e.g., in the status bar of the /// * browser). /// * /// * @param aWebProgress /// * The nsIWebProgress instance that fired the notification. /// * @param aRequest /// * The nsIRequest that has new status. /// * @param aStatus /// * This value is not an error code. Instead, it is a numeric value /// * that indicates the current status of the request. This interface /// * does not define the set of possible status codes. NOTE: Some /// * status values are defined by nsITransport and nsISocketTransport. /// * @param aMessage /// * Localized text corresponding to aStatus. /// */ /// ``` /// /// `void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage);` #[inline] pub unsafe fn OnStatusChange(&self, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aStatus: nsresult, aMessage: *const libc::int16_t) -> nsresult { ((*self.vtable).OnStatusChange)(self, aWebProgress, aRequest, aStatus, aMessage) } /// ```text /// /** /// * Notification called for security progress. This method will be called on /// * security transitions (eg HTTP -> HTTPS, HTTPS -> HTTP, FOO -> HTTPS) and /// * after document load completion. It might also be called if an error /// * occurs during network loading. /// * /// * @param aWebProgress /// * The nsIWebProgress instance that fired the notification. /// * @param aRequest /// * The nsIRequest that has new security state. /// * @param aState /// * A value composed of the Security State Flags and the Security /// * Strength Flags listed above. Any undefined bits are reserved for /// * future use. /// * /// * NOTE: These notifications will only occur if a security package is /// * installed. /// */ /// ``` /// /// `void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aState);` #[inline] pub unsafe fn OnSecurityChange(&self, aWebProgress: *const nsIWebProgress, aRequest: *const nsIRequest, aState: libc::uint32_t) -> nsresult { ((*self.vtable).OnSecurityChange)(self, aWebProgress, aRequest, aState) } }